eslint-plugin-react-x 5.24.0-beta.1 → 5.24.0

package/dist/index.js

@@ -145,7 +145,7 @@ const rules$6 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "5.24.0-beta.1";
+var version = "5.24.0";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -2093,748 +2093,165 @@ function create$41(context) {
 }
 
 //#endregion
-//#region src/rules/no-class-component/no-class-component.ts
-const RULE_NAME$40 = "no-class-component";
-var no_class_component_default = createRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Disallows class components except for error boundaries." },
-		messages: { default: "Avoid using class components. Use function components instead." },
-		schema: []
-	},
-	name: RULE_NAME$40,
-	create: create$40,
-	defaultOptions: []
-});
-function create$40(context) {
-	if (!context.sourceCode.text.includes("Component")) return {};
-	const { api, visitor } = core.getClassComponentCollector(context);
-	return merge(visitor, { "Program:exit"(program) {
-		for (const { id, name = "anonymous", node: component } of api.getAllComponents(program)) {
-			if (component.body.body.some((m) => core.isComponentDidCatch(m) || core.isGetDerivedStateFromError(m))) continue;
-			const classToken = context.sourceCode.getFirstToken(component, { filter: (token) => token.value === "class" });
-			context.report({
-				data: { name },
-				loc: (id ?? classToken ?? component).loc,
-				messageId: "default",
-				node: component
-			});
-		}
-	} });
-}
-
-//#endregion
-//#region src/rules/no-clone-element/no-clone-element.ts
-const RULE_NAME$39 = "no-clone-element";
-var no_clone_element_default = createRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Disallows 'cloneElement'." },
-		messages: { default: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
-		schema: []
-	},
-	name: RULE_NAME$39,
-	create: create$39,
-	defaultOptions: []
-});
-function create$39(context) {
-	return { CallExpression(node) {
-		if (core.isCloneElementCall(context, node)) context.report({
-			messageId: "default",
-			node
-		});
-	} };
+//#region ../../.pkgs/eff/dist/index.js
+function not(predicate) {
+	return (data) => !predicate(data);
 }
-
-//#endregion
-//#region src/rules/no-component-will-mount/no-component-will-mount.ts
-const RULE_NAME$38 = "no-component-will-mount";
-var no_component_will_mount_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Replaces usage of 'componentWillMount' with 'UNSAFE_componentWillMount'." },
-		fixable: "code",
-		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
-		schema: []
-	},
-	name: RULE_NAME$38,
-	create: create$38,
-	defaultOptions: []
-});
-function create$38(context) {
-	if (!context.sourceCode.text.includes("componentWillMount")) return {};
-	const { api, visitor } = core.getClassComponentCollector(context);
-	return merge(visitor, { "Program:exit"(program) {
-		for (const { node: component } of api.getAllComponents(program)) {
-			const { body } = component.body;
-			for (const member of body) if (core.isComponentWillMount(member)) context.report({
-				fix(fixer) {
-					if (!("key" in member)) return null;
-					return fixer.replaceText(member.key, "UNSAFE_componentWillMount");
-				},
-				messageId: "default",
-				node: member
-			});
-		}
-	} });
+function or(a, b) {
+	return (data) => a(data) || b(data);
 }
-
-//#endregion
-//#region src/rules/no-component-will-receive-props/no-component-will-receive-props.ts
-const RULE_NAME$37 = "no-component-will-receive-props";
-var no_component_will_receive_props_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Replaces usage of 'componentWillReceiveProps' with 'UNSAFE_componentWillReceiveProps'." },
-		fixable: "code",
-		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
-		schema: []
-	},
-	name: RULE_NAME$37,
-	create: create$37,
-	defaultOptions: []
-});
-function create$37(context) {
-	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
-	const { api, visitor } = core.getClassComponentCollector(context);
-	return merge(visitor, { "Program:exit"(program) {
-		for (const { node: component } of api.getAllComponents(program)) {
-			const { body } = component.body;
-			for (const member of body) if (core.isComponentWillReceiveProps(member)) context.report({
-				fix(fixer) {
-					if (!("key" in member)) return null;
-					return fixer.replaceText(member.key, "UNSAFE_componentWillReceiveProps");
-				},
-				messageId: "default",
-				node: member
-			});
-		}
-	} });
+/**
+* A function that checks if the passed parameter is a string and narrows its type accordingly.
+*
+* @param data - The variable to check.
+* @returns True if the passed input is a string, false otherwise.
+* @category guards
+*/
+function isString(data) {
+	return typeof data === "string";
 }
-
-//#endregion
-//#region src/rules/no-component-will-update/no-component-will-update.ts
-const RULE_NAME$36 = "no-component-will-update";
-var no_component_will_update_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Replaces usage of 'componentWillUpdate' with 'UNSAFE_componentWillUpdate'." },
-		fixable: "code",
-		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
-		schema: []
-	},
-	name: RULE_NAME$36,
-	create: create$36,
-	defaultOptions: []
-});
-function create$36(context) {
-	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
-	const { api, visitor } = core.getClassComponentCollector(context);
-	return merge(visitor, { "Program:exit"(program) {
-		for (const { node: component } of api.getAllComponents(program)) {
-			const { body } = component.body;
-			for (const member of body) if (core.isComponentWillUpdate(member)) context.report({
-				fix(fixer) {
-					if (!("key" in member)) return null;
-					return fixer.replaceText(member.key, "UNSAFE_componentWillUpdate");
-				},
-				messageId: "default",
-				node: member
-			});
+/**
+* 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;
 		}
-	} });
-}
-
-//#endregion
-//#region src/rules/no-context-provider/no-context-provider.ts
-const RULE_NAME$35 = "no-context-provider";
-var no_context_provider_default = createRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Replaces usage of '<Context.Provider>' with '<Context>'." },
-		fixable: "code",
-		hasSuggestions: true,
-		messages: {
-			default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'.",
-			replace: "Replace '<Context.Provider>' with '<Context>'."
-		},
-		schema: []
-	},
-	name: RULE_NAME$35,
-	create: create$35,
-	defaultOptions: []
-});
-function create$35(context) {
-	if (!context.sourceCode.text.includes("Provider")) return {};
-	const { version } = getSettingsFromContext(context);
-	if (compare(version, "19.0.0", "<")) return {};
-	return { JSXElement(node) {
-		const parts = getElementFullType(node).split(".");
-		const selfName = parts.pop();
-		const contextFullName = parts.join(".");
-		const contextSelfName = parts.pop();
-		if (selfName !== "Provider") return;
-		if (contextSelfName == null || !contextSelfName.endsWith("Context")) return;
-		context.report({
-			messageId: "default",
-			node,
-			suggest: [{
-				fix(fixer) {
-					if (!core.isFunctionComponentNameLoose(contextSelfName)) return null;
-					const openingElement = node.openingElement;
-					const closingElement = node.closingElement;
-					if (closingElement == null) return fixer.replaceText(openingElement.name, contextFullName);
-					return [fixer.replaceText(openingElement.name, contextFullName), fixer.replaceText(closingElement.name, contextFullName)];
-				},
-				messageId: "replace"
-			}]
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules/no-create-ref/no-create-ref.ts
-const RULE_NAME$34 = "no-create-ref";
-var no_create_ref_default = createRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Disallows 'createRef' in function components and Hooks." },
-		messages: { default: "[Deprecated] Use 'useRef' instead." },
-		schema: []
-	},
-	name: RULE_NAME$34,
-	create: create$34,
-	defaultOptions: []
-});
-function create$34(context) {
-	if (!context.sourceCode.text.includes("createRef")) return {};
-	const fc = core.getFunctionComponentCollector(context);
-	const hc = core.getHookCollector(context);
-	const createRefCalls = /* @__PURE__ */ new Set();
-	return merge(fc.visitor, hc.visitor, {
-		CallExpression(node) {
-			if (!core.isCreateRefCall(context, node)) return;
-			createRefCalls.add(node);
-		},
-		"Program:exit"(node) {
-			const comps = fc.api.getAllComponents(node);
-			const hooks = hc.api.getAllHooks(node);
-			const funcs = [...comps, ...hooks];
-			for (const call of createRefCalls) {
-				if (Traverse.findParent(call, (n) => funcs.some((f) => f.node === n)) == null) continue;
-				context.report({
-					messageId: "default",
-					node: call
-				});
-			}
-		}
-	});
-}
-
-//#endregion
-//#region src/rules/no-direct-mutation-state/no-direct-mutation-state.ts
-const RULE_NAME$33 = "no-direct-mutation-state";
-var no_direct_mutation_state_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Disallows direct mutation of 'this.state'." },
-		messages: { default: "Do not mutate state directly. Use 'setState()' instead." },
-		schema: []
-	},
-	name: RULE_NAME$33,
-	create: create$33,
-	defaultOptions: []
-});
-function isConstructorFunction(node) {
-	return Check.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && Check.isPropertyOrMethod(node.parent) && Check.isIdentifier(node.parent.key, "constructor");
-}
-function isAssignmentToThisState(node) {
-	const { left } = node;
-	let current = Extract.unwrap(left);
-	while (current.type === AST_NODE_TYPES.MemberExpression) {
-		const object = Extract.unwrap(current.object);
-		const property = current.property;
-		if (object.type === AST_NODE_TYPES.ThisExpression && Check.isIdentifier(property, "state")) return true;
-		current = object;
-	}
-	return false;
-}
-function create$33(context) {
-	return { AssignmentExpression(node) {
-		if (!isAssignmentToThisState(node)) return;
-		const fact = Traverse.findParent(node, Check.isClass);
-		if (fact == null) return;
-		if (core.isClassComponent(fact) && context.sourceCode.getScope(node).block !== Traverse.findParent(node, isConstructorFunction)) context.report({
-			messageId: "default",
-			node
-		});
-	} };
-}
-
-//#endregion
-//#region src/rules/no-duplicate-key/no-duplicate-key.ts
-const RULE_NAME$32 = "no-duplicate-key";
-var no_duplicate_key_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Prevents duplicate 'key' props on sibling elements when rendering lists." },
-		messages: { default: "The 'key' prop must be unique to its sibling elements." },
-		schema: []
-	},
-	name: RULE_NAME$32,
-	create: create$32,
-	defaultOptions: []
-});
-function create$32(context) {
-	if (!context.sourceCode.text.includes("key=")) return {};
-	const keyedEntries = /* @__PURE__ */ new Map();
-	function isKeyValueEqual(a, b) {
-		const aValue = a.value;
-		const bValue = b.value;
-		if (aValue == null || bValue == null) return false;
-		return Compare.isEqual(aValue, bValue);
 	}
-	return {
-		"JSXAttribute[name.name='key']"(node) {
-			const jsxElement = node.parent.parent;
-			switch (jsxElement.parent.type) {
-				case AST_NODE_TYPES.ArrayExpression:
-				case AST_NODE_TYPES.JSXElement:
-				case AST_NODE_TYPES.JSXFragment: {
-					const root = jsxElement.parent;
-					const prevKeys = keyedEntries.get(root)?.keys ?? [];
-					keyedEntries.set(root, {
-						hasDuplicate: prevKeys.some((prevKey) => isKeyValueEqual(prevKey, node)),
-						keys: [...prevKeys, node],
-						root: jsxElement.parent
-					});
-					break;
-				}
-				default: {
-					const call = Traverse.findParent(jsxElement, (n) => {
-						if (n.type !== AST_NODE_TYPES.CallExpression) return false;
-						const callee = Extract.unwrap(n.callee);
-						if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
-						return Check.isIdentifier(callee.property, "map");
-					});
-					const iter = Traverse.findParent(jsxElement, Check.isFunction, (n) => n === call);
-					if (!Check.isFunction(iter)) return;
-					const arg0 = call?.arguments[0];
-					if (call == null || arg0 == null) return;
-					if (Extract.unwrap(arg0) !== iter) return;
-					keyedEntries.set(call, {
-						hasDuplicate: node.value?.type === AST_NODE_TYPES.Literal,
-						keys: [node],
-						root: call
-					});
-				}
-			}
-		},
-		"Program:exit"() {
-			for (const { hasDuplicate, keys } of keyedEntries.values()) {
-				if (!hasDuplicate) continue;
-				for (const key of keys) context.report({
-					data: { value: context.sourceCode.getText(key) },
-					messageId: "default",
-					node: key
-				});
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/rules/no-forward-ref/no-forward-ref.ts
-const RULE_NAME$31 = "no-forward-ref";
-var no_forward_ref_default = createRule({
-	meta: {
-		type: "suggestion",
-		docs: { description: "Replaces usage of 'forwardRef' with passing 'ref' as a prop." },
-		fixable: "code",
-		hasSuggestions: true,
-		messages: {
-			default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead.",
-			replace: "Replace 'forwardRef' with passing 'ref' as a prop."
-		},
-		schema: []
-	},
-	name: RULE_NAME$31,
-	create: create$31,
-	defaultOptions: []
-});
-function create$31(context) {
-	if (!context.sourceCode.text.includes("forwardRef")) return {};
-	const { version } = getSettingsFromContext(context);
-	if (compare(version, "19.0.0", "<")) return {};
-	return { CallExpression(node) {
-		if (!core.isForwardRefCall(context, node)) return;
-		const id = core.getFunctionId(node);
-		const suggest = couldFix(context, node) ? [{
-			fix: buildFix(context, node),
-			messageId: "replace"
-		}] : [];
-		context.report({
-			messageId: "default",
-			node: id ?? node,
-			suggest
-		});
-	} };
-}
+};
 /**
-* Determine whether the given CallExpression can be safely auto-fixed by replacing
-* the usage of `forwardRef` with passing `ref` as a prop
+* Reusable prototype that implements `Pipeable.pipe`.
 *
-* @param context The rule context object
-* @param node The CallExpression node to check
-* @returns True if the call can be auto-fixed, false otherwise
+* **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
 */
-function couldFix(context, node) {
-	const { importSource } = getSettingsFromContext(context);
-	const initialScope = context.sourceCode.getScope(node);
-	const callee = Extract.unwrap(node.callee);
-	switch (callee.type) {
-		case AST_NODE_TYPES.Identifier: return isInitializedFromReact(callee.name, initialScope, importSource);
-		case AST_NODE_TYPES.MemberExpression: return Check.isIdentifier(callee.object) && isInitializedFromReact(callee.object.name, initialScope, importSource);
-		default: return false;
-	}
-}
+const Prototype = { pipe() {
+	return pipeArguments(this, arguments);
+} };
 /**
-* Generates the fix for the `forwardRef` call
-* @param context The rule context
-* @param node The `forwardRef` call expression
-* @returns A fixer function that applies the changes
+* 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
 */
-function buildFix(context, node) {
-	return (fixer) => {
-		const [componentNode] = node.arguments;
-		if (componentNode == null || !Check.isFunction(componentNode)) return [];
-		return [
-			fixer.removeRange([node.range[0], componentNode.range[0]]),
-			fixer.removeRange([componentNode.range[1], node.range[1]]),
-			...buildFixForComponentProps(context, fixer, componentNode, node.typeArguments?.params ?? [])
-		];
-	};
-}
+const Class = (function() {
+	function PipeableBase() {}
+	PipeableBase.prototype = Prototype;
+	return PipeableBase;
+})();
 /**
-* Generates fixes for the component's props and ref arguments
-* @param context The rule context
-* @param fixer The rule fixer
-* @param node The function component node
-* @param typeArguments The type arguments from the `forwardRef` call
-* @returns An array of fixes for the component's signature
+* 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
 */
-function buildFixForComponentProps(context, fixer, node, typeArguments) {
-	const getText = (node) => context.sourceCode.getText(node);
-	const [arg0, arg1] = node.params;
-	const [typeArg0, typeArg1] = typeArguments;
-	if (arg0 == null) {
-		const openParen = context.sourceCode.getFirstToken(node, { filter: (t) => t.value === "(" });
-		if (openParen == null) return [];
-		if (typeArg0 == null || typeArg1 == null) return [];
-		const typeArg0Text = getText(typeArg0);
-		const typeArg1Text = getText(typeArg1);
-		return [fixer.insertTextAfter(openParen, `{ ref }: ${typeArg1Text} & { ref?: React.RefObject<${typeArg0Text} | null> }`)];
-	}
-	const fixedArg0Text = match(arg0).with({ type: AST_NODE_TYPES.Identifier }, (n) => `...${n.name}`).with({ type: AST_NODE_TYPES.ObjectPattern }, (n) => n.properties.map(getText).join(", ")).otherwise(() => null);
-	const fixedArg1Text = match(arg1).with(P.nullish, () => "ref").with({
-		type: AST_NODE_TYPES.Identifier,
-		name: "ref"
-	}, () => "ref").with({
-		type: AST_NODE_TYPES.Identifier,
-		name: P.string
-	}, (n) => `ref: ${n.name}`).otherwise(() => null);
-	if (fixedArg0Text == null || fixedArg1Text == null) return [];
-	if (typeArg0 == null || typeArg1 == null) return [fixer.replaceText(arg0, [
-		"{",
-		fixedArg1Text + ",",
-		fixedArg0Text,
-		"}"
-	].join(" ")), ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]];
-	const typeArg0Text = getText(typeArg0);
-	const typeArg1Text = getText(typeArg1);
-	return [fixer.replaceText(arg0, [
-		"{",
-		fixedArg1Text + ",",
-		fixedArg0Text,
-		"}:",
-		typeArg1Text,
-		"&",
-		"{",
-		`ref?:`,
-		`React.RefObject<${typeArg0Text} | null>`,
-		"}"
-	].join(" ")), ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]];
-}
-
-//#endregion
-//#region src/utils/create-implicit-prop-listener.ts
-/**
-* Creates a listener that detects JSX spread attributes implicitly passing a given prop
-* (ex: 'children', 'key', 'ref') to a component.
-*
-* For each union constituent of the spread argument's type, the prop is reported unless:
-* 1. The prop symbol's fully qualified name is allowed (pass-through of React internally defined props)
-* 2. The fully qualified name of the prop's type symbol (or its alias) is allowed (React type aliases)
-*
-* @param context The ESLint rule context
-* @param options The prop name, the allow-list predicates (receive lowercased fully qualified names), and the report callback
-* @param options.name The name of the prop to detect
-* @param options.isAllowedProp A predicate that receives the prop symbol's lowercased fully qualified name and returns `true` if it is allowed
-* @param options.isAllowedType A predicate that receives the prop's type symbol's lowercased fully qualified name and returns `true` if it is allowed
-* @param options.onImplicitProp A callback invoked with the spread attribute node when an implicit prop is detected
-* @returns A rule listener reporting on JSX spread attributes
-*/
-function createImplicitPropListener(context, options) {
-	const { name, isAllowedProp, isAllowedType, onImplicitProp } = options;
-	const services = ESLintUtils.getParserServices(context, false);
-	const checker = services.program.getTypeChecker();
-	const getFqn = (symbol) => core.getFullyQualifiedNameEx(checker, symbol).toLowerCase();
-	return { JSXSpreadAttribute(node) {
-		for (const type of unionConstituents(getConstrainedTypeAtLocation(services, node.argument))) {
-			const prop = type.getProperty(name);
-			if (prop == null) continue;
-			if (isAllowedProp(getFqn(prop))) continue;
-			const propType = checker.getTypeOfSymbol(prop);
-			const propTypeSymbol = propType.aliasSymbol ?? propType.symbol;
-			if (propTypeSymbol != null && isAllowedType(getFqn(propTypeSymbol))) continue;
-			onImplicitProp(node);
-		}
-	} };
-}
-
-//#endregion
-//#region src/rules/no-implicit-children/no-implicit-children.ts
-const RULE_NAME$30 = "no-implicit-children";
-const RE_REACT_CHILDREN_TYPE = /react\.(reactnode|reactelement|reactportal)$/i;
-var no_implicit_children_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Prevents implicitly passing the 'children' prop to components." },
-		messages: { default: "This spread attribute implicitly passes the 'children' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'children' prop, use 'children={value}'." },
-		schema: []
-	},
-	name: RULE_NAME$30,
-	create: create$30,
-	defaultOptions: []
-});
-function create$30(context) {
-	return createImplicitPropListener(context, {
-		name: "children",
-		isAllowedProp: (fqn) => fqn.endsWith("attributes.children") || fqn.endsWith("propswithchildren.children"),
-		isAllowedType: (fqn) => RE_REACT_CHILDREN_TYPE.test(fqn) || fqn === "jsx.element",
-		onImplicitProp(node) {
-			context.report({
-				messageId: "default",
-				node
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/rules/no-implicit-key/no-implicit-key.ts
-const RULE_NAME$29 = "no-implicit-key";
-var no_implicit_key_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Prevents implicitly passing the 'key' prop to components." },
-		messages: { default: "This spread attribute implicitly passes the 'key' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'key' prop, use 'key={value}'." },
-		schema: []
-	},
-	name: RULE_NAME$29,
-	create: create$29,
-	defaultOptions: []
-});
-function create$29(context) {
-	return createImplicitPropListener(context, {
-		name: "key",
-		isAllowedProp: (fqn) => fqn.endsWith("react.attributes.key"),
-		isAllowedType: (fqn) => fqn.endsWith("react.key"),
-		onImplicitProp(node) {
-			context.report({
-				messageId: "default",
-				node
-			});
-		}
-	});
-}
-
-//#endregion
-//#region src/rules/no-implicit-ref/no-implicit-ref.ts
-const RULE_NAME$28 = "no-implicit-ref";
-const RE_REACT_REF_TYPE = /react\.(ref|legacyref|refcallback|refobject)$/i;
-var no_implicit_ref_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Prevents implicitly passing the 'ref' prop to components." },
-		messages: { default: "This spread attribute implicitly passes the 'ref' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'ref' prop, use 'ref={value}'." },
-		schema: []
-	},
-	name: RULE_NAME$28,
-	create: create$28,
-	defaultOptions: []
-});
-function create$28(context) {
-	return createImplicitPropListener(context, {
-		name: "ref",
-		isAllowedProp: (fqn) => fqn.endsWith("attributes.ref"),
-		isAllowedType: (fqn) => RE_REACT_REF_TYPE.test(fqn),
-		onImplicitProp(node) {
-			context.report({
-				messageId: "default",
-				node
-			});
-		}
-	});
-}
-
-//#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.
+* Creates a function that can be called in data-first style or data-last
+* (`pipe`-friendly) style.
 *
 * **When to use**
 *
-* Use to implement a custom `.pipe(...)` method from JavaScript's `arguments`
-* object.
+* Use to expose one implementation through both direct and `pipe`-friendly
+* call styles.
 *
 * **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.
+* 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** (Implementing a pipe method)
+* **Example** (Selecting data-first or data-last style by arity)
 *
 * ```ts
-* import { Pipeable } from "effect"
-*
-* class NumberBox {
-*   constructor(readonly value: number) {}
+* import { Function, pipe } from "effect"
 *
-*   pipe(..._fns: ReadonlyArray<(value: number) => number>): number {
-*     return Pipeable.pipeArguments(this.value, arguments) as number
-*   }
-* }
+* const sum = Function.dual<
+*   (that: number) => (self: number) => number,
+*   (self: number, that: number) => number
+* >(2, (self, that) => self + that)
 *
-* const result = new NumberBox(5).pipe(
-*   (n) => n + 2,
-*   (n) => n * 3
-* )
-* console.log(result) // 21
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
 * ```
 *
-* @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`.
+* **Example** (Defining overloads with call signatures)
 *
-* **When to use**
+* ```ts
+* import { Function, pipe } from "effect"
 *
-* Use when classes or object prototypes can reuse this value when they need the
-* standard pipe implementation backed by `pipeArguments`.
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = Function.dual(2, (self: number, that: number): number => self + that)
 *
-* @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.
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
 *
-* **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)
+* **Example** (Selecting data-first or data-last style with a predicate)
 *
 * ```ts
 * import { Function, pipe } from "effect"
@@ -3137,68 +2554,664 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
 * console.log(typeof buildUser) // "function"
 * ```
 *
-* @category utility types
-* @since 2.0.0
+* @category utility types
+* @since 2.0.0
+*/
+const hole = cast(absurd);
+function getOrInsertComputed(map, key, callback) {
+	if (map.has(key)) return map.get(key);
+	const value = callback(key);
+	map.set(key, value);
+	return value;
+}
+/**
+* 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-class-component/no-class-component.ts
+const RULE_NAME$40 = "no-class-component";
+var no_class_component_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallows class components except for error boundaries." },
+		messages: { default: "Avoid using class components. Use function components instead." },
+		schema: []
+	},
+	name: RULE_NAME$40,
+	create: create$40,
+	defaultOptions: []
+});
+function create$40(context) {
+	if (!context.sourceCode.text.includes("Component")) return {};
+	const { api, visitor } = core.getClassComponentCollector(context);
+	return merge(visitor, { "Program:exit"(program) {
+		for (const { id, name = "anonymous", node: component } of api.getAllComponents(program)) {
+			if (component.body.body.some(or(core.isComponentDidCatch, core.isGetDerivedStateFromError))) continue;
+			const classToken = context.sourceCode.getFirstToken(component, { filter: (token) => token.value === "class" });
+			context.report({
+				data: { name },
+				loc: (id ?? classToken ?? component).loc,
+				messageId: "default",
+				node: component
+			});
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/no-clone-element/no-clone-element.ts
+const RULE_NAME$39 = "no-clone-element";
+var no_clone_element_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallows 'cloneElement'." },
+		messages: { default: "Using 'cloneElement' is uncommon and can lead to fragile code. Use alternatives instead." },
+		schema: []
+	},
+	name: RULE_NAME$39,
+	create: create$39,
+	defaultOptions: []
+});
+function create$39(context) {
+	return { CallExpression(node) {
+		if (core.isCloneElementCall(context, node)) context.report({
+			messageId: "default",
+			node
+		});
+	} };
+}
+
+//#endregion
+//#region src/rules/no-component-will-mount/no-component-will-mount.ts
+const RULE_NAME$38 = "no-component-will-mount";
+var no_component_will_mount_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Replaces usage of 'componentWillMount' with 'UNSAFE_componentWillMount'." },
+		fixable: "code",
+		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillMount' instead." },
+		schema: []
+	},
+	name: RULE_NAME$38,
+	create: create$38,
+	defaultOptions: []
+});
+function create$38(context) {
+	if (!context.sourceCode.text.includes("componentWillMount")) return {};
+	const { api, visitor } = core.getClassComponentCollector(context);
+	return merge(visitor, { "Program:exit"(program) {
+		for (const { node: component } of api.getAllComponents(program)) {
+			const { body } = component.body;
+			for (const member of body) if (core.isComponentWillMount(member)) context.report({
+				fix(fixer) {
+					if (!("key" in member)) return null;
+					return fixer.replaceText(member.key, "UNSAFE_componentWillMount");
+				},
+				messageId: "default",
+				node: member
+			});
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/no-component-will-receive-props/no-component-will-receive-props.ts
+const RULE_NAME$37 = "no-component-will-receive-props";
+var no_component_will_receive_props_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Replaces usage of 'componentWillReceiveProps' with 'UNSAFE_componentWillReceiveProps'." },
+		fixable: "code",
+		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillReceiveProps' instead." },
+		schema: []
+	},
+	name: RULE_NAME$37,
+	create: create$37,
+	defaultOptions: []
+});
+function create$37(context) {
+	if (!context.sourceCode.text.includes("componentWillReceiveProps")) return {};
+	const { api, visitor } = core.getClassComponentCollector(context);
+	return merge(visitor, { "Program:exit"(program) {
+		for (const { node: component } of api.getAllComponents(program)) {
+			const { body } = component.body;
+			for (const member of body) if (core.isComponentWillReceiveProps(member)) context.report({
+				fix(fixer) {
+					if (!("key" in member)) return null;
+					return fixer.replaceText(member.key, "UNSAFE_componentWillReceiveProps");
+				},
+				messageId: "default",
+				node: member
+			});
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/no-component-will-update/no-component-will-update.ts
+const RULE_NAME$36 = "no-component-will-update";
+var no_component_will_update_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Replaces usage of 'componentWillUpdate' with 'UNSAFE_componentWillUpdate'." },
+		fixable: "code",
+		messages: { default: "[Deprecated] Use 'UNSAFE_componentWillUpdate' instead." },
+		schema: []
+	},
+	name: RULE_NAME$36,
+	create: create$36,
+	defaultOptions: []
+});
+function create$36(context) {
+	if (!context.sourceCode.text.includes("componentWillUpdate")) return {};
+	const { api, visitor } = core.getClassComponentCollector(context);
+	return merge(visitor, { "Program:exit"(program) {
+		for (const { node: component } of api.getAllComponents(program)) {
+			const { body } = component.body;
+			for (const member of body) if (core.isComponentWillUpdate(member)) context.report({
+				fix(fixer) {
+					if (!("key" in member)) return null;
+					return fixer.replaceText(member.key, "UNSAFE_componentWillUpdate");
+				},
+				messageId: "default",
+				node: member
+			});
+		}
+	} });
+}
+
+//#endregion
+//#region src/rules/no-context-provider/no-context-provider.ts
+const RULE_NAME$35 = "no-context-provider";
+var no_context_provider_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Replaces usage of '<Context.Provider>' with '<Context>'." },
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			default: "In React 19, you can render '<Context>' as a provider instead of '<Context.Provider>'.",
+			replace: "Replace '<Context.Provider>' with '<Context>'."
+		},
+		schema: []
+	},
+	name: RULE_NAME$35,
+	create: create$35,
+	defaultOptions: []
+});
+function create$35(context) {
+	if (!context.sourceCode.text.includes("Provider")) return {};
+	const { version } = getSettingsFromContext(context);
+	if (compare(version, "19.0.0", "<")) return {};
+	return { JSXElement(node) {
+		const parts = getElementFullType(node).split(".");
+		const selfName = parts.pop();
+		const contextFullName = parts.join(".");
+		const contextSelfName = parts.pop();
+		if (selfName !== "Provider") return;
+		if (contextSelfName == null || !contextSelfName.endsWith("Context")) return;
+		context.report({
+			messageId: "default",
+			node,
+			suggest: [{
+				fix(fixer) {
+					if (!core.isFunctionComponentNameLoose(contextSelfName)) return null;
+					const openingElement = node.openingElement;
+					const closingElement = node.closingElement;
+					if (closingElement == null) return fixer.replaceText(openingElement.name, contextFullName);
+					return [fixer.replaceText(openingElement.name, contextFullName), fixer.replaceText(closingElement.name, contextFullName)];
+				},
+				messageId: "replace"
+			}]
+		});
+	} };
+}
+
+//#endregion
+//#region src/rules/no-create-ref/no-create-ref.ts
+const RULE_NAME$34 = "no-create-ref";
+var no_create_ref_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallows 'createRef' in function components and Hooks." },
+		messages: { default: "[Deprecated] Use 'useRef' instead." },
+		schema: []
+	},
+	name: RULE_NAME$34,
+	create: create$34,
+	defaultOptions: []
+});
+function create$34(context) {
+	if (!context.sourceCode.text.includes("createRef")) return {};
+	const fc = core.getFunctionComponentCollector(context);
+	const hc = core.getHookCollector(context);
+	const createRefCalls = /* @__PURE__ */ new Set();
+	return merge(fc.visitor, hc.visitor, {
+		CallExpression(node) {
+			if (!core.isCreateRefCall(context, node)) return;
+			createRefCalls.add(node);
+		},
+		"Program:exit"(node) {
+			const comps = fc.api.getAllComponents(node);
+			const hooks = hc.api.getAllHooks(node);
+			const funcs = [...comps, ...hooks];
+			for (const call of createRefCalls) {
+				if (Traverse.findParent(call, (n) => funcs.some((f) => f.node === n)) == null) continue;
+				context.report({
+					messageId: "default",
+					node: call
+				});
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/rules/no-direct-mutation-state/no-direct-mutation-state.ts
+const RULE_NAME$33 = "no-direct-mutation-state";
+var no_direct_mutation_state_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallows direct mutation of 'this.state'." },
+		messages: { default: "Do not mutate state directly. Use 'setState()' instead." },
+		schema: []
+	},
+	name: RULE_NAME$33,
+	create: create$33,
+	defaultOptions: []
+});
+function isConstructorFunction(node) {
+	return Check.isOneOf([AST_NODE_TYPES.FunctionDeclaration, AST_NODE_TYPES.FunctionExpression])(node) && Check.isPropertyOrMethod(node.parent) && Check.isIdentifier(node.parent.key, "constructor");
+}
+function isAssignmentToThisState(node) {
+	const { left } = node;
+	let current = Extract.unwrap(left);
+	while (current.type === AST_NODE_TYPES.MemberExpression) {
+		const object = Extract.unwrap(current.object);
+		const property = current.property;
+		if (object.type === AST_NODE_TYPES.ThisExpression && Check.isIdentifier(property, "state")) return true;
+		current = object;
+	}
+	return false;
+}
+function create$33(context) {
+	return { AssignmentExpression(node) {
+		if (!isAssignmentToThisState(node)) return;
+		const fact = Traverse.findParent(node, Check.isClass);
+		if (fact == null) return;
+		if (core.isClassComponent(fact) && context.sourceCode.getScope(node).block !== Traverse.findParent(node, isConstructorFunction)) context.report({
+			messageId: "default",
+			node
+		});
+	} };
+}
+
+//#endregion
+//#region src/rules/no-duplicate-key/no-duplicate-key.ts
+const RULE_NAME$32 = "no-duplicate-key";
+var no_duplicate_key_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevents duplicate 'key' props on sibling elements when rendering lists." },
+		messages: { default: "The 'key' prop must be unique to its sibling elements." },
+		schema: []
+	},
+	name: RULE_NAME$32,
+	create: create$32,
+	defaultOptions: []
+});
+function create$32(context) {
+	if (!context.sourceCode.text.includes("key=")) return {};
+	const keyedEntries = /* @__PURE__ */ new Map();
+	function isKeyValueEqual(a, b) {
+		const aValue = a.value;
+		const bValue = b.value;
+		if (aValue == null || bValue == null) return false;
+		return Compare.isEqual(aValue, bValue);
+	}
+	return {
+		"JSXAttribute[name.name='key']"(node) {
+			const jsxElement = node.parent.parent;
+			switch (jsxElement.parent.type) {
+				case AST_NODE_TYPES.ArrayExpression:
+				case AST_NODE_TYPES.JSXElement:
+				case AST_NODE_TYPES.JSXFragment: {
+					const root = jsxElement.parent;
+					const prevKeys = keyedEntries.get(root)?.keys ?? [];
+					keyedEntries.set(root, {
+						hasDuplicate: prevKeys.some((prevKey) => isKeyValueEqual(prevKey, node)),
+						keys: [...prevKeys, node],
+						root: jsxElement.parent
+					});
+					break;
+				}
+				default: {
+					const call = Traverse.findParent(jsxElement, (n) => {
+						if (n.type !== AST_NODE_TYPES.CallExpression) return false;
+						const callee = Extract.unwrap(n.callee);
+						if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+						return Check.isIdentifier(callee.property, "map");
+					});
+					const iter = Traverse.findParent(jsxElement, Check.isFunction, (n) => n === call);
+					if (!Check.isFunction(iter)) return;
+					const arg0 = call?.arguments[0];
+					if (call == null || arg0 == null) return;
+					if (Extract.unwrap(arg0) !== iter) return;
+					keyedEntries.set(call, {
+						hasDuplicate: node.value?.type === AST_NODE_TYPES.Literal,
+						keys: [node],
+						root: call
+					});
+				}
+			}
+		},
+		"Program:exit"() {
+			for (const { hasDuplicate, keys } of keyedEntries.values()) {
+				if (!hasDuplicate) continue;
+				for (const key of keys) context.report({
+					data: { value: context.sourceCode.getText(key) },
+					messageId: "default",
+					node: key
+				});
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/rules/no-forward-ref/no-forward-ref.ts
+const RULE_NAME$31 = "no-forward-ref";
+var no_forward_ref_default = createRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Replaces usage of 'forwardRef' with passing 'ref' as a prop." },
+		fixable: "code",
+		hasSuggestions: true,
+		messages: {
+			default: "In React 19, 'forwardRef' is no longer necessary. Pass 'ref' as a prop instead.",
+			replace: "Replace 'forwardRef' with passing 'ref' as a prop."
+		},
+		schema: []
+	},
+	name: RULE_NAME$31,
+	create: create$31,
+	defaultOptions: []
+});
+function create$31(context) {
+	if (!context.sourceCode.text.includes("forwardRef")) return {};
+	const { version } = getSettingsFromContext(context);
+	if (compare(version, "19.0.0", "<")) return {};
+	return { CallExpression(node) {
+		if (!core.isForwardRefCall(context, node)) return;
+		const id = core.getFunctionId(node);
+		const suggest = couldFix(context, node) ? [{
+			fix: buildFix(context, node),
+			messageId: "replace"
+		}] : [];
+		context.report({
+			messageId: "default",
+			node: id ?? node,
+			suggest
+		});
+	} };
+}
+/**
+* Determine whether the given CallExpression can be safely auto-fixed by replacing
+* the usage of `forwardRef` with passing `ref` as a prop
+*
+* @param context The rule context object
+* @param node The CallExpression node to check
+* @returns True if the call can be auto-fixed, false otherwise
 */
-const hole = cast(absurd);
-function getOrInsertComputed(map, key, callback) {
-	if (map.has(key)) return map.get(key);
-	const value = callback(key);
-	map.set(key, value);
-	return value;
+function couldFix(context, node) {
+	const { importSource } = getSettingsFromContext(context);
+	const initialScope = context.sourceCode.getScope(node);
+	const callee = Extract.unwrap(node.callee);
+	switch (callee.type) {
+		case AST_NODE_TYPES.Identifier: return isInitializedFromReact(callee.name, initialScope, importSource);
+		case AST_NODE_TYPES.MemberExpression: return Check.isIdentifier(callee.object) && isInitializedFromReact(callee.object.name, initialScope, importSource);
+		default: return false;
+	}
 }
 /**
-* 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
+* Generates the fix for the `forwardRef` call
+* @param context The rule context
+* @param node The `forwardRef` call expression
+* @returns A fixer function that applies the changes
 */
-const dropWhile = dual(2, (xs, pred) => {
-	const len = xs.length;
-	let idx = 0;
-	while (idx < len && pred(xs[idx])) idx++;
-	return xs.slice(idx);
-});
+function buildFix(context, node) {
+	return (fixer) => {
+		const [componentNode] = node.arguments;
+		if (componentNode == null || !Check.isFunction(componentNode)) return [];
+		return [
+			fixer.removeRange([node.range[0], componentNode.range[0]]),
+			fixer.removeRange([componentNode.range[1], node.range[1]]),
+			...buildFixForComponentProps(context, fixer, componentNode, node.typeArguments?.params ?? [])
+		];
+	};
+}
 /**
-* 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"
+* Generates fixes for the component's props and ref arguments
+* @param context The rule context
+* @param fixer The rule fixer
+* @param node The function component node
+* @param typeArguments The type arguments from the `forwardRef` call
+* @returns An array of fixes for the component's signature
+*/
+function buildFixForComponentProps(context, fixer, node, typeArguments) {
+	const getText = (node) => context.sourceCode.getText(node);
+	const [arg0, arg1] = node.params;
+	const [typeArg0, typeArg1] = typeArguments;
+	if (arg0 == null) {
+		const openParen = context.sourceCode.getFirstToken(node, { filter: (t) => t.value === "(" });
+		if (openParen == null) return [];
+		if (typeArg0 == null || typeArg1 == null) return [];
+		const typeArg0Text = getText(typeArg0);
+		const typeArg1Text = getText(typeArg1);
+		return [fixer.insertTextAfter(openParen, `{ ref }: ${typeArg1Text} & { ref?: React.RefObject<${typeArg0Text} | null> }`)];
+	}
+	const fixedArg0Text = match(arg0).with({ type: AST_NODE_TYPES.Identifier }, (n) => `...${n.name}`).with({ type: AST_NODE_TYPES.ObjectPattern }, (n) => n.properties.map(getText).join(", ")).otherwise(() => null);
+	const fixedArg1Text = match(arg1).with(P.nullish, () => "ref").with({
+		type: AST_NODE_TYPES.Identifier,
+		name: "ref"
+	}, () => "ref").with({
+		type: AST_NODE_TYPES.Identifier,
+		name: P.string
+	}, (n) => `ref: ${n.name}`).otherwise(() => null);
+	if (fixedArg0Text == null || fixedArg1Text == null) return [];
+	if (typeArg0 == null || typeArg1 == null) return [fixer.replaceText(arg0, [
+		"{",
+		fixedArg1Text + ",",
+		fixedArg0Text,
+		"}"
+	].join(" ")), ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]];
+	const typeArg0Text = getText(typeArg0);
+	const typeArg1Text = getText(typeArg1);
+	return [fixer.replaceText(arg0, [
+		"{",
+		fixedArg1Text + ",",
+		fixedArg0Text,
+		"}:",
+		typeArg1Text,
+		"&",
+		"{",
+		`ref?:`,
+		`React.RefObject<${typeArg0Text} | null>`,
+		"}"
+	].join(" ")), ...arg1 == null ? [] : [fixer.remove(arg1), fixer.removeRange([arg0.range[1], arg1.range[0]])]];
+}
+
+//#endregion
+//#region src/utils/create-implicit-prop-listener.ts
+/**
+* Creates a listener that detects JSX spread attributes implicitly passing a given prop
+* (ex: 'children', 'key', 'ref') to a component.
 *
-* // data-first
-* assert.deepStrictEqual(takeWhile([1, 2, 3, 2, 1], (n: number) => n < 3), [1, 2])
+* For each union constituent of the spread argument's type, the prop is reported unless:
+* 1. The prop symbol's fully qualified name is allowed (pass-through of React internally defined props)
+* 2. The fully qualified name of the prop's type symbol (or its alias) is allowed (React type aliases)
 *
-* // data-last
-* assert.deepStrictEqual(pipe([1, 2, 3, 2, 1], takeWhile((n: number) => n < 3)), [1, 2])
-* ```
-* @category array
+* @param context The ESLint rule context
+* @param options The prop name, the allow-list predicates (receive lowercased fully qualified names), and the report callback
+* @param options.name The name of the prop to detect
+* @param options.isAllowedProp A predicate that receives the prop symbol's lowercased fully qualified name and returns `true` if it is allowed
+* @param options.isAllowedType A predicate that receives the prop's type symbol's lowercased fully qualified name and returns `true` if it is allowed
+* @param options.onImplicitProp A callback invoked with the spread attribute node when an implicit prop is detected
+* @returns A rule listener reporting on JSX spread attributes
 */
-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);
+function createImplicitPropListener(context, options) {
+	const { name, isAllowedProp, isAllowedType, onImplicitProp } = options;
+	const services = ESLintUtils.getParserServices(context, false);
+	const checker = services.program.getTypeChecker();
+	const getFqn = (symbol) => core.getFullyQualifiedNameEx(checker, symbol).toLowerCase();
+	return { JSXSpreadAttribute(node) {
+		for (const type of unionConstituents(getConstrainedTypeAtLocation(services, node.argument))) {
+			const prop = type.getProperty(name);
+			if (prop == null) continue;
+			if (isAllowedProp(getFqn(prop))) continue;
+			const propType = checker.getTypeOfSymbol(prop);
+			const propTypeSymbol = propType.aliasSymbol ?? propType.symbol;
+			if (propTypeSymbol != null && isAllowedType(getFqn(propTypeSymbol))) continue;
+			onImplicitProp(node);
+		}
+	} };
+}
+
+//#endregion
+//#region src/rules/no-implicit-children/no-implicit-children.ts
+const RULE_NAME$30 = "no-implicit-children";
+const RE_REACT_CHILDREN_TYPE = /react\.(reactnode|reactelement|reactportal)$/i;
+var no_implicit_children_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevents implicitly passing the 'children' prop to components." },
+		messages: { default: "This spread attribute implicitly passes the 'children' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'children' prop, use 'children={value}'." },
+		schema: []
+	},
+	name: RULE_NAME$30,
+	create: create$30,
+	defaultOptions: []
+});
+function create$30(context) {
+	return createImplicitPropListener(context, {
+		name: "children",
+		isAllowedProp: (fqn) => fqn.endsWith("attributes.children") || fqn.endsWith("propswithchildren.children"),
+		isAllowedType: (fqn) => RE_REACT_CHILDREN_TYPE.test(fqn) || fqn === "jsx.element",
+		onImplicitProp(node) {
+			context.report({
+				messageId: "default",
+				node
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/rules/no-implicit-key/no-implicit-key.ts
+const RULE_NAME$29 = "no-implicit-key";
+var no_implicit_key_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevents implicitly passing the 'key' prop to components." },
+		messages: { default: "This spread attribute implicitly passes the 'key' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'key' prop, use 'key={value}'." },
+		schema: []
+	},
+	name: RULE_NAME$29,
+	create: create$29,
+	defaultOptions: []
+});
+function create$29(context) {
+	return createImplicitPropListener(context, {
+		name: "key",
+		isAllowedProp: (fqn) => fqn.endsWith("react.attributes.key"),
+		isAllowedType: (fqn) => fqn.endsWith("react.key"),
+		onImplicitProp(node) {
+			context.report({
+				messageId: "default",
+				node
+			});
+		}
+	});
+}
+
+//#endregion
+//#region src/rules/no-implicit-ref/no-implicit-ref.ts
+const RULE_NAME$28 = "no-implicit-ref";
+const RE_REACT_REF_TYPE = /react\.(ref|legacyref|refcallback|refobject)$/i;
+var no_implicit_ref_default = createRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Prevents implicitly passing the 'ref' prop to components." },
+		messages: { default: "This spread attribute implicitly passes the 'ref' prop to a component, this could lead to unexpected behavior. If you intend to pass the 'ref' prop, use 'ref={value}'." },
+		schema: []
+	},
+	name: RULE_NAME$28,
+	create: create$28,
+	defaultOptions: []
 });
+function create$28(context) {
+	return createImplicitPropListener(context, {
+		name: "ref",
+		isAllowedProp: (fqn) => fqn.endsWith("attributes.ref"),
+		isAllowedType: (fqn) => RE_REACT_REF_TYPE.test(fqn),
+		onImplicitProp(node) {
+			context.report({
+				messageId: "default",
+				node
+			});
+		}
+	});
+}
 
 //#endregion
 //#region src/rules/no-leaked-conditional-rendering/no-leaked-conditional-rendering.ts
@@ -3442,6 +3455,12 @@ function create$24(context) {
 	*/
 	function visitItemExpression(node) {
 		switch (node.type) {
+			case AST_NODE_TYPES.ChainExpression:
+			case AST_NODE_TYPES.TSAsExpression:
+			case AST_NODE_TYPES.TSTypeAssertion:
+			case AST_NODE_TYPES.TSNonNullExpression:
+			case AST_NODE_TYPES.TSSatisfiesExpression:
+			case AST_NODE_TYPES.TSInstantiationExpression: return visitItemExpression(node.expression);
 			case AST_NODE_TYPES.JSXElement: return hasAttribute(context, node, "key") ? [] : [{
 				messageId: "default",
 				node
@@ -4358,7 +4377,7 @@ function collectUsedPropKeysOfReference(context, usedPropKeys, ref) {
 function getKeyOfExpression(expr) {
 	switch (expr.type) {
 		case AST_NODE_TYPES.Identifier: return expr.name;
-		case AST_NODE_TYPES.Literal: if (typeof expr.value === "string") return expr.value;
+		case AST_NODE_TYPES.Literal: if (isString(expr.value)) return expr.value;
 	}
 	return null;
 }
@@ -8219,6 +8238,7 @@ function inferViolations$2(context, facts) {
 	const resolver = createSetStateResolver$1(context);
 	const getText = (n) => context.sourceCode.getText(n);
 	const isUseEffectCall = (node) => core.isUseEffectLikeCall(node, additionalEffectHooks);
+	const isUseStateOrThenCall = or(resolver.isUseStateCall, isThenCall);
 	const setStateCallsByFn = /* @__PURE__ */ new Map();
 	const setStateInHookCallbacks = /* @__PURE__ */ new Map();
 	const setStateInEffectArg = /* @__PURE__ */ new Map();
@@ -8226,7 +8246,7 @@ function inferViolations$2(context, facts) {
 	const trackedFnCalls = [];
 	const violations = [];
 	for (const { enclosingFunction, enclosingFunctionKind, node, setupFunction } of facts.calls) {
-		if (resolver.isUseStateCall(node) || isThenCall(node)) continue;
+		if (isUseStateOrThenCall(node)) continue;
 		if (!resolver.isSetStateCall(node)) {
 			if (setupFunction != null && enclosingFunction === setupFunction) trackedFnCalls.push(node);
 			continue;
@@ -8342,11 +8362,12 @@ function create$5(context) {
 
 //#endregion
 //#region src/rules/set-state-in-render/helpers.ts
+const isComponentOrHookName = or(core.isFunctionComponentName, core.isHookName);
 function isComponentOrHookLikeFunction(node) {
 	const id = core.getFunctionId(node);
 	if (id == null) return false;
-	if (Check.isIdentifier(id)) return core.isFunctionComponentName(id.name) || core.isHookName(id.name);
-	if (id.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(id.property)) return core.isFunctionComponentName(id.property.name) || core.isHookName(id.property.name);
+	if (Check.isIdentifier(id)) return isComponentOrHookName(id.name);
+	if (id.type === AST_NODE_TYPES.MemberExpression && Check.isIdentifier(id.property)) return isComponentOrHookName(id.property.name);
 	return false;
 }
 function isInsideConditional(node, stopAt) {