@eslint-react/jsx 5.17.0 → 5.17.2

package/dist/index.js

@@ -2,45 +2,482 @@ import { Traverse } from "@eslint-react/ast";
 import { resolve } from "@eslint-react/var";
 import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { getStaticValue } from "@typescript-eslint/utils/ast-utils";
-import { P, match } from "ts-pattern";
 
-//#region src/collapse-multiline-text.ts
+//#region ../../.pkgs/eff/dist/index.js
 /**
-* Collapse a multiline JSX text string following React's whitespace rules.
+* Applies a `pipe` method's variadic arguments to an initial value from left
+* to right.
 *
-* This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
-* 1. Split the raw text into lines.
-* 2. Find the last non-empty line.
-* 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
-* 4. Collapse tabs into spaces.
-* 5. Append a single space after each non-last non-empty line.
-* @param text The raw JSX text string to collapse.
-* @returns The collapsed string, or `null` if the text contains only whitespace.
-* @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
+* **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
 */
-function collapseMultilineText(text) {
-	const lines = text.split(/\r\n|\n|\r/);
-	let lastNonEmptyLine = 0;
-	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.exec(lines[i] ?? "") != null) lastNonEmptyLine = i;
-	let str = "";
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i] ?? "";
-		const isFirstLine = i === 0;
-		const isLastLine = i === lines.length - 1;
-		const isLastNonEmptyLine = i === lastNonEmptyLine;
-		let trimmedLine = line.replace(/\t/g, " ");
-		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^ +/, "");
-		if (!isLastLine) trimmedLine = trimmedLine.replace(/ +$/, "");
-		if (trimmedLine.length > 0) {
-			if (!isLastNonEmptyLine) trimmedLine += " ";
-			str += trimmedLine;
+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;
 		}
 	}
-	return str === "" ? null : str;
-}
+};
+/**
+* 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/get-attribute-name.ts
+//#region src/attribute-name.ts
 /**
 * Get the stringified name of a `JSXAttribute` node.
 *
@@ -55,9 +492,25 @@ function getAttributeName(node) {
 	if (node.name.type === AST_NODE_TYPES.JSXIdentifier) return node.name.name;
 	return node.name.namespace.name + ":" + node.name.name.name;
 }
+/**
+* Check whether a node is a `JSXAttribute` with the given name.
+*
+* Only plain identifier names are matched (ex: `className`); namespaced
+* attributes (ex: `xml:space`) do not match.
+*
+* Supports both data-first and data-last (curried) call styles:
+* - `isAttribute(node, "className")`
+* - `isAttribute("className")(node)`.
+* @param node The AST node to test.
+* @param name The attribute name to match (ex: "className").
+* @returns `true` when the node is a `JSXAttribute` named `name`.
+*/
+const isAttribute = dual(2, (node, name) => {
+	return node.type === AST_NODE_TYPES.JSXAttribute && node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === name;
+});
 
 //#endregion
-//#region src/find-attribute.ts
+//#region src/attribute-find.ts
 /**
 * Find a JSX attribute (or spread attribute containing the property) by name on a given element.
 *
@@ -66,53 +519,19 @@ 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.
+* Nested object expressions and nested spread identifiers are also resolved
+* (see {@link findSpreadProperty}).
 * @param context The ESLint rule context (needed for variable resolution in spread attributes).
 * @param element The `JSXElement` node to search.
 * @param name The attribute name to look for (ex: "className").
 * @returns The matching `JSXAttribute` or `JSXSpreadAttribute`, or `undefined` when not found.
 */
 function findAttribute(context, element, name) {
-	function findProperty(properties, name, seen = /* @__PURE__ */ new Set()) {
-		for (const property of properties) {
-			if (property.type === AST_NODE_TYPES.Property && !property.computed && property.key.type === AST_NODE_TYPES.Identifier && property.key.name === name) return property;
-			if (property.type !== AST_NODE_TYPES.SpreadElement) continue;
-			const argument = property.argument;
-			if (argument.type === AST_NODE_TYPES.Identifier) {
-				const initNode = resolve(context, argument);
-				if (initNode?.type === AST_NODE_TYPES.ObjectExpression) {
-					if (seen.has(initNode)) continue;
-					seen.add(initNode);
-					const found = findProperty(initNode.properties, name, seen);
-					if (found != null) return found;
-				}
-				continue;
-			}
-			if (argument.type === AST_NODE_TYPES.ObjectExpression) {
-				if (seen.has(argument)) continue;
-				seen.add(argument);
-				const found = findProperty(argument.properties, name, seen);
-				if (found != null) return found;
-			}
-		}
-		return null;
-	}
 	return element.openingElement.attributes.findLast((attr) => {
 		if (attr.type === AST_NODE_TYPES.JSXAttribute) return getAttributeName(attr) === name;
-		switch (attr.argument.type) {
-			case AST_NODE_TYPES.Identifier: {
-				const initNode = resolve(context, attr.argument);
-				if (initNode?.type === AST_NODE_TYPES.ObjectExpression) return findProperty(initNode.properties, name) != null;
-				return false;
-			}
-			case AST_NODE_TYPES.ObjectExpression: return findProperty(attr.argument.properties, name) != null;
-		}
-		return false;
+		return findSpreadProperty(context, attr.argument, name) != null;
 	});
 }
-
-//#endregion
-//#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.
@@ -121,31 +540,173 @@ function findAttribute(context, element, name) {
 * 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.
+* @returns The first matching `JSXAttribute` ancestor, or `undefined` if none is found before reaching the root.
 */
 function findParentAttribute(node, test = () => true) {
 	const guard = (n) => {
 		return n.type === AST_NODE_TYPES.JSXAttribute && test(n);
 	};
-	return Traverse.findParent(node, guard);
+	return Traverse.findParent(node, guard) ?? void 0;
+}
+/**
+* Find the `Property` node that provides a given key inside a spread argument.
+*
+* This is the single resolution routine shared by {@link findAttribute} (existence
+* checks) and the `spreadProps` variant of `resolveAttributeValue` (value extraction):
+*
+* - An `Identifier` argument is resolved to its initializer via variable
+*   resolution, following alias chains (`const b = a`) like `getStaticValue`
+*   does; an `ObjectExpression` argument is searched directly.
+* - Properties are walked **in reverse** so that later entries win, matching
+*   JavaScript object semantics (`{ ...a, k: 1 }` -> the literal `k`).
+* - Nested `SpreadElement`s (identifiers or inline object expressions) are
+*   searched recursively; a `seen` set guards against circular references.
+* - Plain identifier keys and string literal keys are matched directly;
+*   computed keys are matched when they are statically evaluable
+*   (ex: `{ ["class" + "Name"]: 1 }`).
+* @param context The ESLint rule context (needed for variable resolution).
+* @param argument The spread argument expression to search.
+* @param name The property name to look for.
+* @param seen Internal set of already-visited nodes (cycle guard).
+* @returns The matching `Property` node, or `undefined` when the key is not found.
+*/
+function findSpreadProperty(context, argument, name, seen = /* @__PURE__ */ new Set()) {
+	let objectExpression;
+	if (argument.type === AST_NODE_TYPES.Identifier) {
+		let initNode = resolve(context, argument);
+		while (initNode != null && initNode.type === AST_NODE_TYPES.Identifier && !seen.has(initNode)) {
+			seen.add(initNode);
+			initNode = resolve(context, initNode);
+		}
+		if (initNode?.type === AST_NODE_TYPES.ObjectExpression) objectExpression = initNode;
+	} else if (argument.type === AST_NODE_TYPES.ObjectExpression) objectExpression = argument;
+	if (objectExpression == null || seen.has(objectExpression)) return void 0;
+	seen.add(objectExpression);
+	const { properties } = objectExpression;
+	for (let i = properties.length - 1; i >= 0; i--) {
+		const property = properties[i];
+		if (property == null) continue;
+		if (property.type === AST_NODE_TYPES.Property) {
+			const { key } = property;
+			if (property.computed) {
+				if (getStaticValue(key, context.sourceCode.getScope(key))?.value === name) return property;
+				continue;
+			}
+			if (key.type === AST_NODE_TYPES.Identifier && key.name === name) return property;
+			if (key.type === AST_NODE_TYPES.Literal && key.value === name) return property;
+			continue;
+		}
+		const found = findSpreadProperty(context, property.argument, name, seen);
+		if (found != null) return found;
+	}
 }
 
 //#endregion
-//#region src/resolve-attribute-value.ts
+//#region src/attribute-has.ts
 /**
-* Resolve the value of a JSX attribute (or spread attribute) into a
-* {@link JsxAttributeValue} descriptor that can be inspected further.
+* 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.
+*/
+function hasAttribute(context, element, name) {
+	return findAttribute(context, element, name) != null;
+}
+/**
+* Check whether a JSX element carries at least one of the given attributes.
+*
+* This is a batch variant of {@link hasAttribute} for the common pattern of
+* short-circuiting on multiple prop names.
+*
+* Spread attributes are taken into account (see {@link findAttribute}).
+* @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);
+}
+/**
+* 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.
+*/
+function hasEveryAttribute(context, element, names) {
+	return names.every((name) => findAttribute(context, element, name) != null);
+}
+
+//#endregion
+//#region src/attribute-value.ts
+/**
+* Resolve the value of a JSX attribute (or spread attribute) into an
+* {@link AttributeValue} descriptor that can be inspected further.
 *
 * This is the low-level building block; it operates on a single attribute
 * node that the caller has already located. For the higher-level "find by
 * name and resolve" combo, see {@link getAttributeValue}.
+*
+* When the attribute is a `JSXSpreadAttribute`, passing `name` (typically the
+* same name the attribute was found by) makes `toStatic()` return the static
+* value of that named property, eliminating the need to branch on
+* `kind === "spreadProps"` at the call site.
 * @param context The ESLint rule context (needed for scope look-ups).
 * @param attribute A `JSXAttribute` or `JSXSpreadAttribute` node.
+* @param name Optional property name used to resolve `toStatic()` for spread attributes.
 * @returns A discriminated-union descriptor of the attribute's value.
 */
-function resolveAttributeValue(context, attribute) {
+function resolveAttributeValue(context, attribute, name) {
 	if (attribute.type === AST_NODE_TYPES.JSXAttribute) return resolveJsxAttribute(context, attribute);
-	return resolveJsxSpreadAttribute(context, attribute);
+	return resolveJsxSpreadAttribute(context, attribute, name);
+}
+/**
+* Find an attribute by name on a JSX element and resolve its value in a single call.
+*
+* This is a convenience composition of {@link findAttribute} and
+* {@link resolveAttributeValue} that eliminates the most common two-step
+* pattern in lint rules.
+* @param context The ESLint rule context.
+* @param element The `JSXElement` node to search.
+* @param name The attribute name to look up (ex: "className").
+* @returns An {@link AttributeValue} descriptor, or `undefined` when the attribute is not present on the element.
+*/
+function getAttributeValue(context, element, name) {
+	const attr = findAttribute(context, element, name);
+	if (attr == null) return void 0;
+	return resolveAttributeValue(context, attr, name);
+}
+/**
+* Find an attribute by name on a JSX element and collapse its value to a plain
+* JavaScript value in a single step.
+*
+* This is a convenience composition of {@link findAttribute} ->
+* {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
+* `spreadProps` case (extracts the named property from the spread object).
+*
+* Returns `undefined` both when the attribute is absent and when its value
+* cannot be statically determined; use {@link findAttribute} or
+* {@link hasAttribute} when presence itself matters.
+* @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, or `undefined` when absent or indeterminate.
+*/
+function getAttributeStaticValue(context, element, name) {
+	return getAttributeValue(context, element, name)?.toStatic();
 }
 function resolveJsxAttribute(context, node) {
 	const scope = context.sourceCode.getScope(node);
@@ -172,9 +733,7 @@ function resolveJsxAttribute(context, node) {
 			if (expr.type === AST_NODE_TYPES.JSXEmptyExpression) return {
 				kind: "missing",
 				node: expr,
-				toStatic() {
-					return null;
-				}
+				toStatic() {}
 			};
 			return {
 				kind: "unknown",
@@ -187,84 +746,67 @@ function resolveJsxAttribute(context, node) {
 		case AST_NODE_TYPES.JSXElement: return {
 			kind: "element",
 			node: node.value,
-			toStatic() {
-				return null;
-			}
+			toStatic() {}
 		};
 		case AST_NODE_TYPES.JSXSpreadChild: return {
 			kind: "spreadChild",
-			getChildren() {
-				return null;
-			},
-			node: node.value.expression,
-			toStatic() {
-				return null;
-			}
+			node: node.value,
+			toStatic() {}
 		};
 	}
 }
-function resolveJsxSpreadAttribute(context, node) {
-	const scope = context.sourceCode.getScope(node);
+function resolveJsxSpreadAttribute(context, node, name) {
+	const getProperty = (propertyName) => {
+		const property = findSpreadProperty(context, node.argument, propertyName);
+		if (property == null) return void 0;
+		const propertyScope = context.sourceCode.getScope(property.value);
+		return getStaticValue(property.value, propertyScope)?.value;
+	};
 	return {
 		kind: "spreadProps",
-		getProperty(name) {
-			return match(getStaticValue(node.argument, scope)?.value).with({ [name]: P.select(P.unknown) }, (v) => v).otherwise(() => null);
-		},
+		getProperty,
 		node: node.argument,
 		toStatic() {
-			return null;
+			return name == null ? void 0 : getProperty(name);
 		}
 	};
 }
 
 //#endregion
-//#region src/get-attribute-static-value.ts
+//#region src/text.ts
 /**
-* Find an attribute by name on a JSX element and collapse its value to a plain
-* JavaScript value in a single step.
-*
-* This is a convenience composition of {@link findAttribute} ->
-* {@link resolveAttributeValue} -> `toStatic()`, with automatic handling of the
-* `spreadProps` case (extracts the named property from the spread object).
-*
-* Returns `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.
-*/
-function getAttributeStaticValue(context, element, name) {
-	const attr = findAttribute(context, element, name);
-	if (attr == null) return null;
-	const resolved = resolveAttributeValue(context, attr);
-	if (resolved.kind === "spreadProps") return resolved.getProperty(name);
-	if (resolved.kind === "missing") return;
-	return resolved.toStatic();
-}
-
-//#endregion
-//#region src/get-attribute-value.ts
-/**
-* Find an attribute by name on a JSX element and resolve its value in a single call.
+* Collapse a multiline JSX text string following React's whitespace rules.
 *
-* 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.
+* This mirrors Babel's `cleanJSXElementLiteralChild` algorithm:
+* 1. Split the raw text into lines.
+* 2. Find the last non-empty line.
+* 3. Trim leading spaces on non-first lines and trailing spaces on non-last lines.
+* 4. Collapse tabs into spaces.
+* 5. Append a single space after each non-last non-empty line.
+* @param text The raw JSX text string to collapse.
+* @returns The collapsed string, or `null` if the text contains only whitespace.
+* @see https://github.com/babel/babel/blob/main/packages/babel-types/src/utils/react/cleanJSXElementLiteralChild.ts
 */
-function getAttributeValue(context, element, name) {
-	const attr = findAttribute(context, element, name);
-	if (attr == null) return null;
-	return resolveAttributeValue(context, attr);
+function collapseMultilineText(text) {
+	const lines = text.split(/\r\n|\n|\r/);
+	let lastNonEmptyLine = 0;
+	for (let i = 0; i < lines.length; i++) if (/[^ \t]/.exec(lines[i] ?? "") != null) lastNonEmptyLine = i;
+	let str = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i] ?? "";
+		const isFirstLine = i === 0;
+		const isLastLine = i === lines.length - 1;
+		const isLastNonEmptyLine = i === lastNonEmptyLine;
+		let trimmedLine = line.replace(/\t/g, " ");
+		if (!isFirstLine) trimmedLine = trimmedLine.replace(/^ +/, "");
+		if (!isLastLine) trimmedLine = trimmedLine.replace(/ +$/, "");
+		if (trimmedLine.length > 0) {
+			if (!isLastNonEmptyLine) trimmedLine += " ";
+			str += trimmedLine;
+		}
+	}
+	return str === "" ? null : str;
 }
-
-//#endregion
-//#region src/is-whitespace.ts
 /**
 * Check whether a JSX child node is whitespace padding that React would
 * trim away during rendering.
@@ -272,19 +814,21 @@ function getAttributeValue(context, element, name) {
 * 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.
+* `cleanJSXElementLiteralChild`) **and** it contains a newline. This is the
+* whitespace that appears between JSX tags purely for formatting.
+*
+* For the looser "any whitespace-only text" check, see {@link isWhitespaceText}.
 * @param node A JSX child node.
 * @returns `true` when the node is purely formatting whitespace.
 */
-function isWhitespace(node) {
+function isPaddingWhitespace(node) {
 	if (node.type !== AST_NODE_TYPES.JSXText) return false;
 	return collapseMultilineText(node.value) == null && node.value.includes("\n");
 }
 /**
 * Check whether a JSX child node is any whitespace-only text.
 *
-* This is a looser variant of {@link isWhitespace}; it matches every
+* This is a looser variant of {@link isPaddingWhitespace}; it matches every
 * `JSXText` node whose raw content is empty after trimming, regardless of
 * whether it contains a newline.
 * @param node A JSX child node.
@@ -312,7 +856,7 @@ function isEmptyStringExpression(node) {
 }
 
 //#endregion
-//#region src/get-children.ts
+//#region src/children.ts
 /**
 * Get the meaningful children of a JSX element or fragment.
 *
@@ -320,39 +864,59 @@ function isEmptyStringExpression(node) {
 * 1. Iterate over `element.children`.
 * 2. Skip `JSXText` nodes that clean to nothing (padding whitespace).
 * 3. Skip `JSXExpressionContainer` nodes whose expression is empty.
-* 4. Skip `JSXEmptyExpression` nodes.
+* 4. Skip empty string expressions (`{""}`), which produce no DOM node.
 * 5. Collect everything else.
 * @param element A `JSXElement` or `JSXFragment` node.
 * @returns An array of children nodes that contribute to rendered output.
 */
 function getChildren(element) {
-	const elements = [];
+	const children = [];
 	for (const child of element.children) {
-		if (child.type === AST_NODE_TYPES.JSXText) {
-			if (collapseMultilineText(child.value) == null && child.value.includes("\n")) continue;
-			elements.push(child);
-			continue;
-		}
+		if (isPaddingWhitespace(child)) continue;
 		if (child.type === AST_NODE_TYPES.JSXExpressionContainer) {
-			const { expression } = child;
-			if (expression.type === AST_NODE_TYPES.JSXEmptyExpression) continue;
+			if (child.expression.type === AST_NODE_TYPES.JSXEmptyExpression) continue;
 			if (isEmptyStringExpression(child)) continue;
-			elements.push(child);
-			continue;
 		}
-		elements.push(child);
+		children.push(child);
 	}
-	return elements;
+	return children;
+}
+/**
+* Check whether a JSX element (or fragment) has meaningful children, that is,
+* at least one child that is not purely whitespace text or an empty string expression.
+*
+* A `JSXText` child whose `raw` content is empty after trimming is considered
+* non-meaningful because it is typically a code-formatting artifact
+* (indentation between tags). While React's client renderer preserves these
+* nodes as text nodes, they rarely represent intentionally rendered content.
+*
+* An empty string expression (`children={""}`) is also considered
+* non-meaningful because React's reconciler and SSR renderer explicitly skip
+* empty strings, producing no DOM node.
+*
+* Unlike {@link getChildren} (which only filters whitespace that contains a
+* newline) this check treats any whitespace-only text as non-meaningful
+* (see {@link isWhitespaceText}). As a result `hasChildren(node)` is not
+* always equal to `getChildren(node).length > 0`: they differ for
+* whitespace-only children that have no newline, such as `<div> </div>` or
+* `<div>\t\t</div>`. Choose the API that matches your rule's intent.
+* @param element A `JSXElement` or `JSXFragment` node.
+* @returns `true` when the element has at least one meaningful child.
+*/
+function hasChildren(element) {
+	if (element.children.length === 0) return false;
+	return !element.children.every((child) => isWhitespaceText(child) || isEmptyStringExpression(child));
 }
 
 //#endregion
-//#region src/get-element-type.ts
+//#region src/element-type.ts
 /**
 * Get the string representation of a JSX element's type.
 *
 * - `<div>` -> `"div"`
 * - `<Foo.Bar>` -> `"Foo.Bar"`
 * - `<React.Fragment>` -> `"React.Fragment"`
+* - `<xml:space>` -> `"xml:space"`
 * - `<></>` -> `""`.
 * @param node A `JSXElement` or `JSXFragment` node.
 * @returns The fully-qualified element type string.
@@ -382,91 +946,7 @@ function getElementSelfType(node) {
 }
 
 //#endregion
-//#region src/has-any-attribute.ts
-/**
-* 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.
-*/
-function hasAnyAttribute(context, element, names) {
-	return names.some((name) => findAttribute(context, element, name) != null);
-}
-
-//#endregion
-//#region src/has-attribute.ts
-/**
-* Check whether a JSX element carries a given attribute (prop).
-*
-* This is a thin convenience wrapper around {@link findAttribute} for the
-* common case where you only need a boolean answer.
-*
-* 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.
-*/
-function hasAttribute(context, element, name) {
-	return findAttribute(context, element, name) != null;
-}
-
-//#endregion
-//#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.
-*
-* A `JSXText` child whose `raw` content is empty after trimming is considered
-* non-meaningful because it is typically a code-formatting artifact
-* (indentation between tags). While React's client renderer preserves these
-* nodes as text nodes, they rarely represent intentionally rendered content.
-*
-* An empty string expression (`children={""}`) is also considered
-* non-meaningful because React's reconciler and SSR renderer explicitly skip
-* empty strings, producing no DOM node.
-*
-* Unlike {@link getChildren} (which only filters whitespace that contains a
-* newline) this check treats any whitespace-only text as non-meaningful
-* (see {@link isWhitespaceText}). As a result `hasChildren(node)` is not
-* always equal to `getChildren(node).length > 0`: they differ for
-* whitespace-only children that have no newline, such as `<div> </div>` or
-* `<div>\t\t</div>`. Choose the API that matches your rule's intent.
-* @param element A `JSXElement` or `JSXFragment` node.
-* @returns `true` when the element has at least one meaningful child.
-*/
-function hasChildren(element) {
-	if (element.children.length === 0) return false;
-	return !element.children.every((child) => isWhitespaceText(child) || isEmptyStringExpression(child));
-}
-
-//#endregion
-//#region src/has-every-attribute.ts
-/**
-* 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.
-*/
-function hasEveryAttribute(context, element, names) {
-	return names.every((name) => findAttribute(context, element, name) != null);
-}
-
-//#endregion
-//#region src/is-element.ts
+//#region src/element-is.ts
 /**
 * Check whether a node is a `JSXElement` (or `JSXFragment`) and optionally
 * matches a given test.
@@ -492,9 +972,6 @@ function isElement(node, test) {
 		default: return test.includes(elementType);
 	}
 }
-
-//#endregion
-//#region src/is-fragment-element.ts
 /**
 * Check whether a node is a React Fragment element.
 *
@@ -514,9 +991,6 @@ function isFragmentElement(node, jsxFragmentFactory = "React.Fragment") {
 	const fragment = jsxFragmentFactory.split(".").at(-1) ?? "Fragment";
 	return getElementFullType(node).split(".").at(-1) === fragment;
 }
-
-//#endregion
-//#region src/is-host-element.ts
 /**
 * Check whether a node is a host (intrinsic / DOM) element.
 *
@@ -535,32 +1009,4 @@ function isHostElement(node) {
 }
 
 //#endregion
-//#region src/jsx-detection-hint.ts
-/**
-* Hints for JSX detection.
-*/
-const JsxDetectionHint = {
-	None: 0n,
-	DoNotIncludeJsxWithNullValue: 1n << 0n,
-	DoNotIncludeJsxWithNumberValue: 1n << 1n,
-	DoNotIncludeJsxWithBigIntValue: 1n << 2n,
-	DoNotIncludeJsxWithStringValue: 1n << 3n,
-	DoNotIncludeJsxWithBooleanValue: 1n << 4n,
-	DoNotIncludeJsxWithUndefinedValue: 1n << 5n,
-	DoNotIncludeJsxWithEmptyArrayValue: 1n << 6n,
-	DoNotIncludeJsxWithCreateElementValue: 1n << 7n,
-	RequireAllArrayElementsToBeJsx: 1n << 8n,
-	RequireBothSidesOfLogicalExpressionToBeJsx: 1n << 9n,
-	RequireBothBranchesOfConditionalExpressionToBeJsx: 1n << 10n
-};
-/**
-* Default JSX detection hint.
-*
-* Skips number, bigint, boolean, string, and undefined literals,
-* the value types that are commonly returned alongside JSX in React
-* components but are not themselves renderable elements.
-*/
-const DEFAULT_JSX_DETECTION_HINT = 0n | JsxDetectionHint.DoNotIncludeJsxWithNumberValue | JsxDetectionHint.DoNotIncludeJsxWithBigIntValue | JsxDetectionHint.DoNotIncludeJsxWithBooleanValue | JsxDetectionHint.DoNotIncludeJsxWithStringValue | JsxDetectionHint.DoNotIncludeJsxWithUndefinedValue;
-
-//#endregion
-export { DEFAULT_JSX_DETECTION_HINT, JsxDetectionHint, collapseMultilineText, findAttribute, findParentAttribute, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isWhitespace, isWhitespaceText, resolveAttributeValue };
+export { collapseMultilineText, findAttribute, findParentAttribute, findSpreadProperty, getAttributeName, getAttributeStaticValue, getAttributeValue, getChildren, getElementFullType, getElementSelfType, hasAnyAttribute, hasAttribute, hasChildren, hasEveryAttribute, isAttribute, isElement, isEmptyStringExpression, isFragmentElement, isHostElement, isPaddingWhitespace, isWhitespaceText, resolveAttributeValue };