eslint-plugin-react-jsx 5.16.1 → 5.17.1

package/dist/index.js

@@ -1,10 +1,10 @@
 import { DEFAULT_ESLINT_REACT_SETTINGS } from "@eslint-react/shared";
-import { Check, Extract } from "@eslint-react/ast";
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { ESLintUtils } from "@typescript-eslint/utils";
+import { Check, Extract } from "@eslint-react/ast";
 import * as core from "@eslint-react/core";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import "@eslint-react/eslint";
-import { collapseMultilineText, findAttribute, getChildren, getElementFullType, hasAnyAttribute, hasChildren, isFragmentElement, isHostElement, isWhitespaceText } from "@eslint-react/jsx";
+import { collapseMultilineText, findAttribute, getChildren, getElementFullType, hasAnyAttribute, hasChildren, isAttribute, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespaceText } from "@eslint-react/jsx";
 import ts from "typescript";
 
 //#region \0rolldown/runtime.js
@@ -26,45 +26,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$2 = "eslint-plugin-react-jsx";
-var version = "5.16.1";
-
-//#endregion
-//#region src/utils/common.ts
-function findChildrenProperty(node) {
-	for (const prop of node.properties) if (prop.type === AST_NODE_TYPES.Property && Extract.getStaticPropertyName(prop) === "children") return prop;
-	return null;
-}
-function getChildrenContentRange(node) {
-	const first = node.children.at(0);
-	const last = node.children.at(-1);
-	if (first == null || last == null) return null;
-	return [first.range[0], last.range[1]];
-}
-function getChildrenPropText(context, prop) {
-	const { sourceCode } = context;
-	const { value } = prop;
-	if (value == null) return null;
-	if (value.type === AST_NODE_TYPES.Literal) return escapeJsxText(String(value.value));
-	if (value.type !== AST_NODE_TYPES.JSXExpressionContainer) return null;
-	const { expression } = value;
-	if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) return null;
-	const exprText = sourceCode.getText(expression);
-	if (Check.isJSXElementOrFragment(expression)) return exprText;
-	return `{${exprText}}`;
-}
-function escapeJsxText(text) {
-	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("{", "&#123;").replaceAll("}", "&#125;");
-}
-function getPropRemovalRange(context, prop) {
-	const { sourceCode } = context;
-	let start = prop.range[0];
-	const end = prop.range[1];
-	while (start > 0 && /\s/.test(sourceCode.text[start - 1] ?? "")) start--;
-	return [start, end];
-}
-function isDirectJsxChild(node) {
-	return Check.isJSXElementOrFragment(node.parent);
-}
+var version = "5.17.1";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -73,6 +35,39 @@ function getDocsUrl(ruleName) {
 }
 const createRule = ESLintUtils.RuleCreator(getDocsUrl);
 
+//#endregion
+//#region src/utils/find-create-element-children-prop.ts
+/**
+* Finds the statically named `children` property in the props object of a `createElement` call.
+* @param context The rule context
+* @param node The `CallExpression` node to inspect
+* @returns The `children` property node, or `null` when the call has no static `children` prop
+*/
+function findCreateElementChildrenProp(context, node) {
+	if (!core.isCreateElementCall(context, node)) return null;
+	const propsArg = node.arguments[1];
+	if (propsArg == null) return null;
+	const propsObject = Extract.unwrap(propsArg);
+	if (propsObject.type !== AST_NODE_TYPES.ObjectExpression) return null;
+	for (const prop of propsObject.properties) if (prop.type === AST_NODE_TYPES.Property && Extract.getStaticPropertyName(prop) === "children") return prop;
+	return null;
+}
+
+//#endregion
+//#region src/utils/remove-jsx-attribute.ts
+/**
+* Builds a fix that removes a JSX attribute along with the whitespace before it.
+* @param context The rule context
+* @param fixer The rule fixer
+* @param attribute The `JSXAttribute` node to remove
+* @returns A fix that removes the attribute and its preceding whitespace
+*/
+function removeJsxAttribute(context, fixer, attribute) {
+	let start = attribute.range[0];
+	while (start > 0 && /\s/.test(context.sourceCode.text[start - 1] ?? "")) start--;
+	return fixer.removeRange([start, attribute.range[1]]);
+}
+
 //#endregion
 //#region src/rules/no-children-prop-with-children/no-children-prop-with-children.ts
 const RULE_NAME$7 = "no-children-prop-with-children";
@@ -96,14 +91,9 @@ var no_children_prop_with_children_default = createRule({
 function create$7(context) {
 	return {
 		CallExpression(node) {
-			if (!core.isCreateElementCall(context, node)) return;
-			const [, propsArg, firstExtra] = node.arguments;
-			if (propsArg == null) return;
-			const propsObject = Extract.unwrap(propsArg);
-			if (propsObject.type !== AST_NODE_TYPES.ObjectExpression) return;
-			const childrenProp = findChildrenProperty(propsObject);
+			const childrenProp = findCreateElementChildrenProp(context, node);
 			if (childrenProp == null) return;
-			if (firstExtra == null) return;
+			if (node.arguments[2] == null) return;
 			context.report({
 				messageId: "default",
 				node: childrenProp
@@ -111,8 +101,7 @@ function create$7(context) {
 		},
 		JSXElement(node) {
 			const childrenProp = findAttribute(context, node, "children");
-			if (childrenProp == null) return;
-			if (!hasChildren(node)) return;
+			if (childrenProp == null || !hasChildren(node)) return;
 			if (childrenProp.type !== AST_NODE_TYPES.JSXAttribute) {
 				context.report({
 					messageId: "default",
@@ -124,16 +113,14 @@ function create$7(context) {
 				messageId: "default",
 				node: childrenProp,
 				suggest: [{
-					fix(fixer) {
-						const [start, end] = getPropRemovalRange(context, childrenProp);
-						return fixer.removeRange([start, end]);
-					},
+					fix: (fixer) => removeJsxAttribute(context, fixer, childrenProp),
 					messageId: "removeChildrenProp"
 				}, {
 					fix(fixer) {
-						const range = getChildrenContentRange(node);
-						if (range == null) return [];
-						return fixer.removeRange(range);
+						const first = node.children.at(0);
+						const last = node.children.at(-1);
+						if (first == null || last == null) return [];
+						return fixer.removeRange([first.range[0], last.range[1]]);
 					},
 					messageId: "removeChildrenContent"
 				}]
@@ -164,12 +151,7 @@ var no_children_prop_default = createRule({
 function create$6(context) {
 	return {
 		CallExpression(node) {
-			if (!core.isCreateElementCall(context, node)) return;
-			const [, propsArg] = node.arguments;
-			if (propsArg == null) return;
-			const propsObject = Extract.unwrap(propsArg);
-			if (propsObject.type !== AST_NODE_TYPES.ObjectExpression) return;
-			const childrenProp = findChildrenProperty(propsObject);
+			const childrenProp = findCreateElementChildrenProp(context, node);
 			if (childrenProp == null) return;
 			context.report({
 				messageId: "default",
@@ -186,7 +168,7 @@ function create$6(context) {
 				});
 				return;
 			}
-			const childrenText = getChildrenPropText(context, childrenProp);
+			const childrenText = getChildrenText(context, childrenProp);
 			if (childrenText == null) {
 				context.report({
 					messageId: "default",
@@ -198,27 +180,60 @@ function create$6(context) {
 				messageId: "default",
 				node: childrenProp,
 				suggest: [{
-					fix(fixer) {
-						const sourceCode = context.sourceCode;
-						const { openingElement } = node;
-						const [removeStart, removeEnd] = getPropRemovalRange(context, childrenProp);
-						if (openingElement.selfClosing) {
-							const tagName = sourceCode.getText(openingElement.name);
-							const selfCloseOffset = sourceCode.getText(openingElement).lastIndexOf("/>");
-							let wsStart = openingElement.range[0] + selfCloseOffset;
-							while (wsStart > removeEnd && /\s/.test(sourceCode.text[wsStart - 1])) wsStart--;
-							return [fixer.removeRange([removeStart, removeEnd]), fixer.replaceTextRange([wsStart, openingElement.range[1]], `>${childrenText}</${tagName}>`)];
-						}
-						const fixes = [fixer.removeRange([removeStart, removeEnd])];
-						if (node.closingElement != null) fixes.push(fixer.insertTextBefore(node.closingElement, childrenText));
-						return fixes;
-					},
+					fix: buildFix$1(context, node, childrenProp, childrenText),
 					messageId: "moveChildrenToContent"
 				}]
 			});
 		}
 	};
 }
+/**
+* Turns the value of a 'children' JSXAttribute into text usable as element content
+* @param context The rule context
+* @param attribute The 'children' JSXAttribute node
+* @returns The text to insert as element content, or `null` when no usable value exists
+*/
+function getChildrenText(context, attribute) {
+	const { value } = attribute;
+	if (value?.type === AST_NODE_TYPES.Literal) return escapeJsxText(String(value.value));
+	if (value?.type === AST_NODE_TYPES.JSXExpressionContainer && value.expression.type !== AST_NODE_TYPES.JSXEmptyExpression) {
+		const exprText = context.sourceCode.getText(value.expression);
+		return Check.isJSXElementOrFragment(value.expression) ? exprText : `{${exprText}}`;
+	}
+	return null;
+}
+/**
+* Escapes characters that would be parsed as markup in JSX text
+* @param text The raw string value
+* @returns The escaped text safe for insertion as JSX content
+*/
+function escapeJsxText(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("{", "&#123;").replaceAll("}", "&#125;");
+}
+/**
+* Builds the fix that moves the 'children' prop value into the element's content
+* @param context The rule context object
+* @param node The JSXElement node being reported
+* @param prop The 'children' JSXAttribute to remove
+* @param childrenText The text to insert as element content
+* @returns A fixer function that applies the changes
+*/
+function buildFix$1(context, node, prop, childrenText) {
+	return (fixer) => {
+		const sourceCode = context.sourceCode;
+		const { openingElement } = node;
+		const removePropFix = removeJsxAttribute(context, fixer, prop);
+		if (openingElement.selfClosing) {
+			const tagName = sourceCode.getText(openingElement.name);
+			const selfCloseOffset = sourceCode.getText(openingElement).lastIndexOf("/>");
+			let wsStart = openingElement.range[0] + selfCloseOffset;
+			while (wsStart > prop.range[1] && /\s/.test(sourceCode.text[wsStart - 1])) wsStart--;
+			return [removePropFix, fixer.replaceTextRange([wsStart, openingElement.range[1]], `>${childrenText}</${tagName}>`)];
+		}
+		if (node.closingElement == null) return [removePropFix];
+		return [removePropFix, fixer.insertTextBefore(node.closingElement, childrenText)];
+	};
+}
 
 //#endregion
 //#region src/rules/no-comment-textnodes/no-comment-textnodes.ts
@@ -236,19 +251,493 @@ var no_comment_textnodes_default = createRule({
 });
 function create$5(context) {
 	function visit(node) {
-		if (!isDirectJsxChild(node)) return;
+		if (!Check.isJSXElementOrFragment(node.parent)) return;
 		if (!/^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node))) return;
 		context.report({
 			messageId: "default",
 			node
 		});
 	}
-	return {
-		JSXText: visit,
-		Literal: visit
-	};
+	return { JSXText: visit };
 }
 
+//#endregion
+//#region ../../.pkgs/eff/dist/index.js
+function not(predicate) {
+	return (data) => !predicate(data);
+}
+/**
+* Applies a `pipe` method's variadic arguments to an initial value from left
+* to right.
+*
+* **When to use**
+*
+* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
+* object.
+*
+* **Details**
+*
+* This helper is intended for implementing `Pipeable.pipe` methods that
+* receive JavaScript's `arguments` object. With no functions it returns the
+* original value; otherwise it feeds each result into the next function.
+*
+* **Example** (Implementing a pipe method)
+*
+* ```ts
+* import { Pipeable } from "effect"
+*
+* class NumberBox {
+*   constructor(readonly value: number) {}
+*
+*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
+*     return Pipeable.pipeArguments(this.value, arguments) as number
+*   }
+* }
+*
+* const result = new NumberBox(5).pipe(
+*   (n) => n + 2,
+*   (n) => n * 3
+* )
+* console.log(result) // 21
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const pipeArguments = (self, args) => {
+	switch (args.length) {
+		case 0: return self;
+		case 1: return args[0](self);
+		case 2: return args[1](args[0](self));
+		case 3: return args[2](args[1](args[0](self)));
+		case 4: return args[3](args[2](args[1](args[0](self))));
+		case 5: return args[4](args[3](args[2](args[1](args[0](self)))));
+		case 6: return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+		case 7: return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+		case 8: return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+		case 9: return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+		default: {
+			let ret = self;
+			for (let i = 0, len = args.length; i < len; i++) ret = args[i](ret);
+			return ret;
+		}
+	}
+};
+/**
+* Reusable prototype that implements `Pipeable.pipe`.
+*
+* **When to use**
+*
+* Use when classes or object prototypes can reuse this value when they need the
+* standard pipe implementation backed by `pipeArguments`.
+*
+* @category prototypes
+* @since 3.15.0
+*/
+const Prototype = { pipe() {
+	return pipeArguments(this, arguments);
+} };
+/**
+* Provides a base constructor whose instances implement the standard `Pipeable.pipe`
+* method.
+*
+* **When to use**
+*
+* Use when you need to define a class that supports Effect-style method
+* chaining through `.pipe(...)`.
+*
+* @category constructors
+* @since 3.15.0
+*/
+const Class = (function() {
+	function PipeableBase() {}
+	PipeableBase.prototype = Prototype;
+	return PipeableBase;
+})();
+/**
+* Provides small helpers for defining and reusing TypeScript functions.
+*
+* The main helpers are `pipe` and `flow` for left-to-right composition and
+* `dual` for APIs that support both direct and pipe-friendly call styles. The
+* module also contains small identity, constant, tuple, type-level, and
+* memoization helpers used across the library.
+*
+* @since 2.0.0
+*/
+/**
+* Creates a function that can be called in data-first style or data-last
+* (`pipe`-friendly) style.
+*
+* **When to use**
+*
+* Use to expose one implementation through both direct and `pipe`-friendly
+* call styles.
+*
+* **Details**
+*
+* Pass either the arity of the uncurried function or a predicate that decides
+* whether the current call is data-first. Arity is the common case. Use a
+* predicate when optional arguments make arity ambiguous.
+*
+* **Example** (Selecting data-first or data-last style by arity)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Defining overloads with call signatures)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = Function.dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Selecting data-first or data-last style with a predicate)
+*
+* ```ts
+* import { Function, pipe } from "effect"
+*
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(
+*   (args) => args.length === 2,
+*   (self, that) => self + that
+* )
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const dual = function(arity, body) {
+	if (typeof arity === "function") return function() {
+		return arity(arguments) ? body.apply(this, arguments) : ((self) => body(self, ...arguments));
+	};
+	switch (arity) {
+		case 0:
+		case 1: throw new RangeError(`Invalid arity ${arity}`);
+		case 2: return function(a, b) {
+			if (arguments.length >= 2) return body(a, b);
+			return function(self) {
+				return body(self, a);
+			};
+		};
+		case 3: return function(a, b, c) {
+			if (arguments.length >= 3) return body(a, b, c);
+			return function(self) {
+				return body(self, a, b);
+			};
+		};
+		default: return function() {
+			if (arguments.length >= arity) return body.apply(this, arguments);
+			const args = arguments;
+			return function(self) {
+				return body(self, ...args);
+			};
+		};
+	}
+};
+/**
+* Returns its input argument unchanged.
+*
+* **When to use**
+*
+* Use to return a value unchanged where a function is required.
+*
+* **Example** (Returning the same value)
+*
+* ```ts
+* import { identity } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(identity(5), 5)
+* ```
+*
+* @category combinators
+* @since 2.0.0
+*/
+const identity = (a) => a;
+/**
+* Returns the input value with a different static type.
+*
+* **When to use**
+*
+* Use when you need an explicit type-level cast and accept that the value is
+* returned unchanged at runtime.
+*
+* **Gotchas**
+*
+* This is a type-level cast only; it performs no runtime validation or
+* conversion.
+*
+* @see {@link satisfies} for checking assignability without changing the resulting type
+*
+* @category utility types
+* @since 4.0.0
+*/
+const cast = identity;
+/**
+* Creates a zero-argument function that always returns the provided value.
+*
+* **When to use**
+*
+* Use when you need a thunk or callback that returns the same value on every
+* invocation.
+*
+* **Example** (Creating a constant thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* const constNull = Function.constant(null)
+*
+* assert.deepStrictEqual(constNull(), null)
+* assert.deepStrictEqual(constNull(), null)
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const constant = (value) => () => value;
+/**
+* Returns `true` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `true` on every invocation.
+*
+* **Example** (Returning true from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constTrue(), true)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constTrue = constant(true);
+/**
+* Returns `false` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `false` on every invocation.
+*
+* **Example** (Returning false from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constFalse(), false)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constFalse = constant(false);
+/**
+* Returns `null` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `null` on every invocation.
+*
+* **Example** (Returning null from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constNull(), null)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constNull = constant(null);
+/**
+* Returns `undefined` when called.
+*
+* **When to use**
+*
+* Use when you need a thunk that returns `undefined` on every invocation.
+*
+* **Example** (Returning undefined from a thunk)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* assert.deepStrictEqual(Function.constUndefined(), undefined)
+* ```
+*
+* @category constants
+* @since 2.0.0
+*/
+const constUndefined = constant(void 0);
+/**
+* Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
+* The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
+*
+* **When to use**
+*
+* Use to compose exactly two unary functions into a reusable unary function.
+*
+* **Example** (Composing two functions)
+*
+* ```ts
+* import { Function } from "effect"
+* import * as assert from "node:assert"
+*
+* const increment = (n: number) => n + 1
+* const square = (n: number) => n * n
+*
+* assert.strictEqual(Function.compose(increment, square)(2), 9)
+* ```
+*
+* @see {@link flow} for composing a left-to-right sequence of functions
+* @see {@link pipe} for applying a value through a left-to-right sequence immediately
+*
+* @category combinators
+* @since 2.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+/**
+* Marks an impossible branch by accepting a `never` value and returning any
+* type.
+*
+* **When to use**
+*
+* Use when you need a return value in a branch that exhaustive checks prove
+* cannot be reached.
+*
+* **Gotchas**
+*
+* Calling `absurd` throws, because a value of type `never` should be
+* impossible at runtime.
+*
+* **Example** (Handling impossible values)
+*
+* ```ts
+* import { absurd } from "effect"
+*
+* const handleNever = (value: never) => {
+*   return absurd(value) // This will throw an error if called
+* }
+* ```
+*
+* @category utility types
+* @since 2.0.0
+*/
+const absurd = (_) => {
+	throw new Error("Called `absurd` function which should be uncallable");
+};
+/**
+* Creates a compile-time placeholder for a value of any type.
+*
+* **When to use**
+*
+* Use as a temporary typed placeholder while developing incomplete code.
+*
+* **Gotchas**
+*
+* `hole` is intended for temporary development use. If the placeholder is
+* evaluated at runtime, it throws.
+*
+* **Example** (Creating a development placeholder)
+*
+* ```ts
+* import { hole } from "effect"
+*
+* // Intentionally not called: `hole` throws if the placeholder is evaluated.
+* const buildUser = (id: number): { readonly id: number; readonly name: string } => ({
+*   id,
+*   name: hole<string>()
+* })
+*
+* console.log(typeof buildUser) // "function"
+* ```
+*
+* @category utility types
+* @since 2.0.0
+*/
+const hole = cast(absurd);
+/**
+* Drops the longest prefix of elements from an array that satisfy the given predicate.
+*
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array without the matching prefix.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { dropWhile, pipe } from "@local/eff"
+*
+* // data-first
+* assert.deepStrictEqual(dropWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [3, 2, 1])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], dropWhile((n: number) => n < 3)), [3, 2, 1])
+* ```
+* @category array
+*/
+const dropWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(idx);
+});
+/**
+* Takes the longest prefix of elements from an array that satisfy the given predicate.
+*
+* Supports both data-first and data-last (`pipe`-friendly) call styles.
+*
+* @param pred - The predicate to test each element with.
+* @returns A new array containing only the matching prefix.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { pipe, takeWhile } from "@local/eff"
+*
+* // data-first
+* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+*
+* // data-last
+* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
+* ```
+* @category array
+*/
+const takeWhile = dual(2, (xs, pred) => {
+	const len = xs.length;
+	let idx = 0;
+	while (idx < len && pred(xs[idx])) idx++;
+	return xs.slice(0, idx);
+});
+
 //#endregion
 //#region src/rules/no-key-after-spread/no-key-after-spread.ts
 const RULE_NAME$4 = "no-key-after-spread";
@@ -256,7 +745,7 @@ var no_key_after_spread_default = createRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Prevent patterns that cause deoptimization when using the automatic JSX runtime." },
-		messages: { noKeyAfterSpread: "Placing 'key' after spread props causes deoptimization when using the automatic JSX runtime. Put 'key' before any spread props." },
+		messages: { default: "Placing 'key' after spread props causes deoptimization when using the automatic JSX runtime. Put 'key' before any spread props." },
 		schema: []
 	},
 	name: RULE_NAME$4,
@@ -265,20 +754,12 @@ var no_key_after_spread_default = createRule({
 });
 function create$4(context) {
 	const { jsx } = core.getJsxConfig(context);
-	if (!(jsx === ts.JsxEmit.ReactJSX || jsx === ts.JsxEmit.ReactJSXDev)) return {};
+	if (jsx !== ts.JsxEmit.ReactJSX && jsx !== ts.JsxEmit.ReactJSXDev) return {};
 	return { JSXOpeningElement(node) {
-		let firstSpreadPropIndex = null;
-		for (const [index, prop] of node.attributes.entries()) {
-			if (prop.type === AST_NODE_TYPES.JSXSpreadAttribute) {
-				firstSpreadPropIndex ??= index;
-				continue;
-			}
-			if (firstSpreadPropIndex == null) continue;
-			if (prop.name.type === AST_NODE_TYPES.JSXIdentifier && prop.name.name === "key" && index > firstSpreadPropIndex) context.report({
-				messageId: "noKeyAfterSpread",
-				node: prop
-			});
-		}
+		for (const n of dropWhile(node.attributes, not(Check.is(AST_NODE_TYPES.JSXSpreadAttribute))).filter(isAttribute("key"))) context.report({
+			messageId: "default",
+			node: n
+		});
 	} };
 }
 
@@ -302,15 +783,12 @@ var no_leaked_dollar_default = createRule({
 	defaultOptions: []
 });
 function create$3(context) {
-	/**
-	* Visitor function for JSXElement and JSXFragment nodes
-	* @param node The JSXElement or JSXFragment node to be checked
-	*/
+	if (!context.sourceCode.text.includes("$")) return {};
 	function visit(node) {
 		for (const [index, child] of node.children.entries()) {
 			if (child.type !== AST_NODE_TYPES.JSXText || !child.value.endsWith("$")) continue;
 			if (node.children[index + 1]?.type !== AST_NODE_TYPES.JSXExpressionContainer) continue;
-			if (child.value === "$" && node.children.length === 2) continue;
+			if (child.value.trim() === "$" && node.children.every((sibling, siblingIndex) => siblingIndex === index || siblingIndex === index + 1 || isNonSubstantiveChild(sibling))) continue;
 			if (!context.sourceCode.getText(child).endsWith("$")) continue;
 			const dollarStart = child.range[1] - 1;
 			const dollarEnd = child.range[1];
@@ -335,6 +813,15 @@ function create$3(context) {
 		JSXFragment: visit
 	};
 }
+/**
+* Whether a JSX child carries no renderable content: padding whitespace, an
+* empty expression (ex: `{}` or a comment), or an empty string expression.
+* @param child The JSX child node to check.
+*/
+function isNonSubstantiveChild(child) {
+	if (isWhitespaceText(child) || isEmptyStringExpression(child)) return true;
+	return child.type === AST_NODE_TYPES.JSXExpressionContainer && child.expression.type === AST_NODE_TYPES.JSXEmptyExpression;
+}
 
 //#endregion
 //#region src/rules/no-leaked-semicolon/no-leaked-semicolon.ts
@@ -343,6 +830,7 @@ var no_leaked_semicolon_default = createRule({
 	meta: {
 		type: "problem",
 		docs: { description: "Catches `;` at the start of JSX text nodes — typically from accidentally placing a statement-ending `;` inside JSX. The `;` \"leaks\" into the rendered output." },
+		fixable: "code",
 		hasSuggestions: true,
 		messages: {
 			default: "Leaked ';' in JSX. This ';' will be rendered as text nodes.",
@@ -354,30 +842,22 @@ var no_leaked_semicolon_default = createRule({
 	create: create$2,
 	defaultOptions: []
 });
-function hasLeakedSemicolon(text) {
-	return /^;[ \t]*(?:\r\n|\r|\n)/u.test(text);
-}
 function create$2(context) {
 	function visit(node) {
-		if (!isDirectJsxChild(node)) return;
-		if (!hasLeakedSemicolon(context.sourceCode.getText(node))) return;
-		const semicolonStart = node.range[0];
-		const semicolonEnd = node.range[0] + 1;
+		if (!Check.isJSXElementOrFragment(node.parent)) return;
+		if (!/^;+[ \t]*(?:\r\n|\r|\n)/u.test(context.sourceCode.getText(node))) return;
 		context.report({
 			messageId: "default",
 			node,
 			suggest: [{
 				fix(fixer) {
-					return fixer.removeRange([semicolonStart, semicolonEnd]);
+					return fixer.removeRange([node.range[0], node.range[0] + 1]);
 				},
 				messageId: "removeSemicolon"
 			}]
 		});
 	}
-	return {
-		JSXText: visit,
-		Literal: visit
-	};
+	return { JSXText: visit };
 }
 
 //#endregion
@@ -430,7 +910,6 @@ const schema = [{
 var no_useless_fragment_default = createRule({
 	meta: {
 		type: "suggestion",
-		defaultOptions: [...defaultOptions],
 		docs: { description: "Disallows useless fragment elements." },
 		fixable: "code",
 		messages: { default: "A fragment {{reason}} is useless." },
@@ -441,88 +920,96 @@ var no_useless_fragment_default = createRule({
 	defaultOptions
 });
 function create(context, [option]) {
-	const { allowEmptyFragment = false, allowExpressions = true } = option;
+	const options = {
+		allowEmptyFragment: option.allowEmptyFragment ?? false,
+		allowExpressions: option.allowExpressions ?? true
+	};
 	const jsxConfig = core.getJsxConfig(context);
-	/**
-	* Whether the fragment has too few meaningful children to justify its
-	* existence (the "contains less than two children" reason).
-	* @param node The fragment node to check.
-	*/
-	function isContentUseless(node) {
-		if (node.children.length === 0) return !allowEmptyFragment;
-		const insideJsx = Check.isJSXElementOrFragment(node.parent);
-		if (allowExpressions && !insideJsx && node.children.length === 1 && node.children[0]?.type === AST_NODE_TYPES.JSXText) return false;
-		const meaningful = getChildren(node);
-		if (meaningful.length === 0) return true;
-		if (meaningful.length > 1) return false;
-		if (meaningful[0]?.type === AST_NODE_TYPES.JSXExpressionContainer) return !allowExpressions;
-		return true;
-	}
-	/**
-	* Whether it is safe to auto-fix the fragment by unwrapping it.
-	* @param node The fragment node to check.
-	*/
-	function isSafeToFix(node) {
-		if (node.type === AST_NODE_TYPES.JSXElement && node.openingElement.attributes.some((attr) => attr.type === AST_NODE_TYPES.JSXSpreadAttribute)) return false;
-		if (Check.isJSXElementOrFragment(node.parent)) return isHostElement(node.parent);
-		if (node.children.length === 0) return false;
-		return node.children.every((child) => {
-			if (Check.isJSXElementOrFragment(child)) return true;
-			return child.type === AST_NODE_TYPES.JSXText && isWhitespaceText(child);
-		});
-	}
-	/**
-	* Build an autofix that unwraps the fragment, replacing it with its
-	* meaningful children content.  Returns `null` when the fix is unsafe.
-	* @param node The fragment node to fix.
-	*/
-	function buildFix(node) {
-		if (!isSafeToFix(node)) return null;
-		return (fixer) => {
-			let text = "";
-			for (const child of node.children) if (child.type === AST_NODE_TYPES.JSXText) {
-				const cleaned = collapseMultilineText(child.value);
-				if (cleaned != null) text += cleaned;
-			} else text += context.sourceCode.getText(child);
-			let start = node.range[0];
-			if (text === "" && node.children.length > 0) {
-				const lineStart = Math.max(context.sourceCode.text.lastIndexOf("\n", start - 1), context.sourceCode.text.lastIndexOf("\r", start - 1)) + 1;
-				if (/^[ \t]*$/u.test(context.sourceCode.text.slice(lineStart, start))) start = lineStart;
-			}
-			return fixer.replaceTextRange([start, node.range[1]], text);
-		};
-	}
-	/**
-	* Inspect a fragment node and report if it is useless.
-	*
-	* A fragment may be reported for **two independent reasons** on the same
-	* node (e.g. `<p><>foo</></p>` is both "placed inside a host component"
-	* and* "contains less than two children").
-	* @param node The fragment node to inspect.
-	*/
-	function visit(node) {
-		if (isHostElement(node.parent)) context.report({
-			data: { reason: "placed inside a host component" },
-			fix: buildFix(node),
-			messageId: "default",
-			node
-		});
-		if (isContentUseless(node)) context.report({
-			data: { reason: "contains less than two children" },
-			fix: buildFix(node),
-			messageId: "default",
-			node
-		});
-	}
 	return {
 		JSXElement(node) {
 			if (!isFragmentElement(node, jsxConfig.jsxFragmentFactory)) return;
 			if (hasAnyAttribute(context, node, ["key", "ref"])) return;
-			visit(node);
+			visitFragment(context, node, options);
 		},
 		JSXFragment(node) {
-			visit(node);
+			visitFragment(context, node, options);
+		}
+	};
+}
+/**
+* Inspect a fragment node and report if it is useless.
+*
+* A fragment may be reported for **two independent reasons** on the same
+* node (e.g. `<p><>foo</></p>` is both "placed inside a host component"
+* and "contains less than two children").
+* @param context The rule context.
+* @param node The fragment node to inspect.
+* @param options The resolved rule options.
+*/
+function visitFragment(context, node, options) {
+	const reasons = [];
+	if (isHostElement(node.parent)) reasons.push("placed inside a host component");
+	if (isContentUseless(node, options)) reasons.push("contains less than two children");
+	if (reasons.length === 0) return;
+	const fix = buildFix(context, node);
+	for (const reason of reasons) context.report({
+		data: { reason },
+		fix,
+		messageId: "default",
+		node
+	});
+}
+/**
+* Whether the fragment has too few meaningful children to justify its
+* existence (the "contains less than two children" reason).
+* @param node The fragment node to check.
+* @param options The resolved rule options.
+*/
+function isContentUseless(node, options) {
+	const { allowEmptyFragment, allowExpressions } = options;
+	if (node.children.length === 0) return !allowEmptyFragment;
+	const insideJsx = Check.isJSXElementOrFragment(node.parent);
+	if (allowExpressions && !insideJsx && node.children.length === 1 && node.children[0]?.type === AST_NODE_TYPES.JSXText) return false;
+	const meaningful = getChildren(node);
+	if (meaningful.length === 0) return true;
+	if (meaningful.length > 1) return false;
+	if (meaningful[0]?.type === AST_NODE_TYPES.JSXExpressionContainer) return !allowExpressions;
+	return true;
+}
+/**
+* Whether it is safe to auto-fix the fragment by unwrapping it.
+* @param node The fragment node to check.
+*/
+function isSafeToFix(node) {
+	if (node.type === AST_NODE_TYPES.JSXElement && node.openingElement.attributes.some((attr) => attr.type === AST_NODE_TYPES.JSXSpreadAttribute)) return false;
+	if (Check.isJSXElementOrFragment(node.parent)) return isHostElement(node.parent);
+	if (node.children.length === 0) return false;
+	return node.children.every((child) => {
+		if (Check.isJSXElementOrFragment(child)) return true;
+		return child.type === AST_NODE_TYPES.JSXText && isWhitespaceText(child);
+	});
+}
+/**
+* Build an autofix that unwraps the fragment, replacing it with its
+* meaningful children content.  Returns `null` when the fix is unsafe.
+* @param context The rule context.
+* @param node The fragment node to fix.
+*/
+function buildFix(context, node) {
+	if (!isSafeToFix(node)) return null;
+	return (fixer) => {
+		const sourceCode = context.sourceCode;
+		let text = "";
+		for (const child of node.children) if (child.type === AST_NODE_TYPES.JSXText) {
+			const cleaned = collapseMultilineText(child.value);
+			if (cleaned != null) text += cleaned;
+		} else text += sourceCode.getText(child);
+		let start = node.range[0];
+		if (text === "" && node.children.length > 0) {
+			const lineStart = Math.max(sourceCode.text.lastIndexOf("\n", start - 1), sourceCode.text.lastIndexOf("\r", start - 1)) + 1;
+			if (/^[ \t]*$/u.test(sourceCode.text.slice(lineStart, start))) start = lineStart;
 		}
+		return fixer.replaceTextRange([start, node.range[1]], text);
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-jsx",
-  "version": "5.16.1",
+  "version": "5.17.1",
   "description": "ESLint React's ESLint plugin for React Flavored JSX rules.",
   "keywords": [
     "react",
@@ -39,18 +39,18 @@
   "dependencies": {
     "@typescript-eslint/types": "^8.64.0",
     "@typescript-eslint/utils": "^8.64.0",
-    "@eslint-react/ast": "5.16.1",
-    "@eslint-react/eslint": "5.16.1",
-    "@eslint-react/jsx": "5.16.1",
-    "@eslint-react/shared": "5.16.1",
-    "@eslint-react/core": "5.16.1"
+    "@eslint-react/ast": "5.17.1",
+    "@eslint-react/eslint": "5.17.1",
+    "@eslint-react/core": "5.17.1",
+    "@eslint-react/jsx": "5.17.1",
+    "@eslint-react/shared": "5.17.1"
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "dedent": "^1.7.2",
     "eslint": "^10.7.0",
-    "tsdown": "^0.22.7",
+    "tsdown": "^0.22.8",
     "typescript": "6.0.3",
     "@local/configs": "0.0.0",
     "@local/eff": "0.0.0"