eslint-plugin-react-jsx 5.17.0 → 5.17.2

package/dist/index.js

@@ -4,7 +4,7 @@ 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, getAttributeName, getChildren, getElementFullType, hasAnyAttribute, hasChildren, isEmptyStringExpression, 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,7 +26,7 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$2 = "eslint-plugin-react-jsx";
-var version = "5.17.0";
+var version = "5.17.2";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -261,6 +261,483 @@ function create$5(context) {
 	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";
@@ -276,20 +753,15 @@ var no_key_after_spread_default = createRule({
 	defaultOptions: []
 });
 function create$4(context) {
+	if (!context.sourceCode.text.includes("key=")) return {};
 	const { jsx } = core.getJsxConfig(context);
 	if (jsx !== ts.JsxEmit.ReactJSX && jsx !== ts.JsxEmit.ReactJSXDev) return {};
+	const isJsxSpreadAttribute = Check.is(AST_NODE_TYPES.JSXSpreadAttribute);
 	return { JSXOpeningElement(node) {
-		let hasSpreadBefore = false;
-		for (const prop of node.attributes) {
-			if (prop.type === AST_NODE_TYPES.JSXSpreadAttribute) {
-				hasSpreadBefore = true;
-				continue;
-			}
-			if (hasSpreadBefore && getAttributeName(prop) === "key") context.report({
-				messageId: "default",
-				node: prop
-			});
-		}
+		for (const n of dropWhile(node.attributes, not(isJsxSpreadAttribute)).filter(isAttribute("key"))) context.report({
+			messageId: "default",
+			node: n
+		});
 	} };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-jsx",
-  "version": "5.17.0",
+  "version": "5.17.2",
   "description": "ESLint React's ESLint plugin for React Flavored JSX rules.",
   "keywords": [
     "react",
@@ -39,21 +39,21 @@
   "dependencies": {
     "@typescript-eslint/types": "^8.64.0",
     "@typescript-eslint/utils": "^8.64.0",
-    "@eslint-react/ast": "5.17.0",
-    "@eslint-react/core": "5.17.0",
-    "@eslint-react/eslint": "5.17.0",
-    "@eslint-react/jsx": "5.17.0",
-    "@eslint-react/shared": "5.17.0"
+    "@eslint-react/ast": "5.17.2",
+    "@eslint-react/core": "5.17.2",
+    "@eslint-react/jsx": "5.17.2",
+    "@eslint-react/shared": "5.17.2",
+    "@eslint-react/eslint": "5.17.2"
   },
   "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.9",
     "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": "*",