eslint-plugin-react-x 3.0.0-next.71 → 3.0.0-next.74

package/dist/index.js

@@ -9,7 +9,6 @@ import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { computeObjectType, findEnclosingAssignmentTarget, isAssignmentTargetEqual, resolve } from "@eslint-react/var";
 import { DefinitionType } from "@typescript-eslint/scope-manager";
 import { findVariable, getStaticValue, isIdentifier, isVariableDeclarator } from "@typescript-eslint/utils/ast-utils";
-import { constFalse, constTrue, constVoid, flow, getOrElseUpdate, identity, not } from "@eslint-react/eff";
 import { compare } from "compare-versions";
 import { getConstrainedTypeAtLocation } from "@typescript-eslint/type-utils";
 import { unionConstituents } from "ts-api-utils";
@@ -57,8 +56,6 @@ const conflictingRules$1 = [
 	"react/jsx-no-target-blank",
 	"react/jsx-no-useless-fragment",
 	"react/jsx-pascal-case",
-	"react/jsx-uses-react",
-	"react/jsx-uses-vars",
 	"react/no-access-state-in-setstate",
 	"react/no-array-index-key",
 	"react/no-children-prop",
@@ -148,7 +145,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "3.0.0-next.71";
+var version = "3.0.0-next.74";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -305,7 +302,7 @@ function getTypeVariants(types) {
 
 //#endregion
 //#region src/rules/component-hook-factories/component-hook-factories.ts
-const RULE_NAME$63 = "component-hook-factories";
+const RULE_NAME$61 = "component-hook-factories";
 var component_hook_factories_default = createRule({
 	meta: {
 		type: "problem",
@@ -316,11 +313,11 @@ var component_hook_factories_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$63,
-	create: create$63,
+	name: RULE_NAME$61,
+	create: create$61,
 	defaultOptions: []
 });
-function create$63(context) {
+function create$61(context) {
 	const hint = core.ComponentDetectionHint.DoNotIncludeJsxWithNumberValue | core.ComponentDetectionHint.DoNotIncludeJsxWithBooleanValue | core.ComponentDetectionHint.DoNotIncludeJsxWithNullValue | core.ComponentDetectionHint.DoNotIncludeJsxWithStringValue | core.ComponentDetectionHint.DoNotIncludeJsxWithUndefinedValue | core.ComponentDetectionHint.RequireBothSidesOfLogicalExpressionToBeJsx | core.ComponentDetectionHint.RequireBothBranchesOfConditionalExpressionToBeJsx | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayPattern | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedInArrayExpression | core.ComponentDetectionHint.DoNotIncludeFunctionDefinedAsArrayMapCallback;
 	const fCollector = core.useComponentCollector(context, { hint });
 	const cCollector = core.useComponentCollectorLegacy(context);
@@ -364,7 +361,7 @@ function create$63(context) {
 
 //#endregion
 //#region src/rules/error-boundaries/error-boundaries.ts
-const RULE_NAME$62 = "error-boundaries";
+const RULE_NAME$60 = "error-boundaries";
 var error_boundaries_default = createRule({
 	meta: {
 		type: "problem",
@@ -375,11 +372,11 @@ var error_boundaries_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$62,
-	create: create$62,
+	name: RULE_NAME$60,
+	create: create$60,
 	defaultOptions: []
 });
-function create$62(context) {
+function create$60(context) {
 	if (!context.sourceCode.text.includes("try")) return {};
 	const { ctx, visitor } = core.useComponentCollector(context);
 	const reported = /* @__PURE__ */ new Set();
@@ -1319,7 +1316,7 @@ function getUnknownDependenciesMessage(reactiveHookName) {
 
 //#endregion
 //#region src/rules/immutability/immutability.ts
-const RULE_NAME$61 = "immutability";
+const RULE_NAME$59 = "immutability";
 /**
 * Array methods that mutate the array in place.
 * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
@@ -1345,11 +1342,11 @@ var immutability_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$61,
-	create: create$61,
+	name: RULE_NAME$59,
+	create: create$59,
 	defaultOptions: []
 });
-function create$61(context) {
+function create$59(context) {
 	const { additionalStateHooks } = getSettingsFromContext(context);
 	const hCollector = core.useHookCollector(context);
 	const cCollector = core.useComponentCollector(context);
@@ -1470,7 +1467,7 @@ function create$61(context) {
 
 //#endregion
 //#region src/rules/jsx-dollar/jsx-dollar.ts
-const RULE_NAME$60 = "jsx-dollar";
+const RULE_NAME$58 = "jsx-dollar";
 var jsx_dollar_default = createRule({
 	meta: {
 		type: "suggestion",
@@ -1483,11 +1480,11 @@ var jsx_dollar_default = createRule({
 		},
 		schema: []
 	},
-	name: RULE_NAME$60,
-	create: create$60,
+	name: RULE_NAME$58,
+	create: create$58,
 	defaultOptions: []
 });
-function create$60(context) {
+function create$58(context) {
 	/**
 	* Visitor function for JSXElement and JSXFragment nodes
 	* @param node The JSXElement or JSXFragment node to be checked
@@ -1528,7 +1525,7 @@ function create$60(context) {
 
 //#endregion
 //#region src/rules/jsx-key-before-spread/jsx-key-before-spread.ts
-const RULE_NAME$59 = "jsx-key-before-spread";
+const RULE_NAME$57 = "jsx-key-before-spread";
 var jsx_key_before_spread_default = createRule({
 	meta: {
 		type: "problem",
@@ -1536,11 +1533,11 @@ var jsx_key_before_spread_default = createRule({
 		messages: { default: "The 'key' prop must be placed before any spread props when using the new JSX transform." },
 		schema: []
 	},
-	name: RULE_NAME$59,
-	create: create$59,
+	name: RULE_NAME$57,
+	create: create$57,
 	defaultOptions: []
 });
-function create$59(context) {
+function create$57(context) {
 	const { jsx } = JsxInspector.from(context).jsxConfig;
 	if (jsx !== JsxEmit.ReactJSX && jsx !== JsxEmit.ReactJSXDev) return {};
 	return defineRuleListener({ JSXOpeningElement(node) {
@@ -1561,7 +1558,7 @@ function create$59(context) {
 
 //#endregion
 //#region src/rules/jsx-no-comment-textnodes/jsx-no-comment-textnodes.ts
-const RULE_NAME$58 = "jsx-no-comment-textnodes";
+const RULE_NAME$56 = "jsx-no-comment-textnodes";
 var jsx_no_comment_textnodes_default = createRule({
 	meta: {
 		type: "problem",
@@ -1569,11 +1566,11 @@ var jsx_no_comment_textnodes_default = createRule({
 		messages: { default: "Possible misused comment in text node. Comments inside children section of tag should be placed inside braces." },
 		schema: []
 	},
-	name: RULE_NAME$58,
-	create: create$58,
+	name: RULE_NAME$56,
+	create: create$56,
 	defaultOptions: []
 });
-function create$58(context) {
+function create$56(context) {
 	function hasCommentLike(node) {
 		if (ast.isOneOf([AST_NODE_TYPES.JSXAttribute, AST_NODE_TYPES.JSXExpressionContainer])(node.parent)) return false;
 		return /^\s*\/(?:\/|\*)/mu.test(context.sourceCode.getText(node));
@@ -1594,7 +1591,7 @@ function create$58(context) {
 
 //#endregion
 //#region src/rules/jsx-no-duplicate-props/jsx-no-duplicate-props.ts
-const RULE_NAME$57 = "jsx-no-duplicate-props";
+const RULE_NAME$55 = "jsx-no-duplicate-props";
 var jsx_no_duplicate_props_default = createRule({
 	meta: {
 		type: "problem",
@@ -1602,11 +1599,11 @@ var jsx_no_duplicate_props_default = createRule({
 		messages: { default: "This JSX property is assigned multiple times." },
 		schema: []
 	},
-	name: RULE_NAME$57,
-	create: create$57,
+	name: RULE_NAME$55,
+	create: create$55,
 	defaultOptions: []
 });
-function create$57(context) {
+function create$55(context) {
 	return defineRuleListener({ JSXOpeningElement(node) {
 		const props = [];
 		for (const attr of node.attributes) {
@@ -1627,7 +1624,7 @@ function create$57(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-boolean/jsx-shorthand-boolean.ts
-const RULE_NAME$56 = "jsx-shorthand-boolean";
+const RULE_NAME$54 = "jsx-shorthand-boolean";
 const defaultOptions$4 = [1];
 const schema$4 = [{
 	type: "integer",
@@ -1641,11 +1638,11 @@ var jsx_shorthand_boolean_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$4
 	},
-	name: RULE_NAME$56,
-	create: create$56,
+	name: RULE_NAME$54,
+	create: create$54,
 	defaultOptions: defaultOptions$4
 });
-function create$56(context) {
+function create$54(context) {
 	const policy = context.options[0] ?? defaultOptions$4[0];
 	const jsx = JsxInspector.from(context);
 	return defineRuleListener({ JSXAttribute(node) {
@@ -1674,7 +1671,7 @@ function create$56(context) {
 
 //#endregion
 //#region src/rules/jsx-shorthand-fragment/jsx-shorthand-fragment.ts
-const RULE_NAME$55 = "jsx-shorthand-fragment";
+const RULE_NAME$53 = "jsx-shorthand-fragment";
 const defaultOptions$3 = [1];
 const schema$3 = [{
 	type: "integer",
@@ -1688,11 +1685,11 @@ var jsx_shorthand_fragment_default = createRule({
 		messages: { default: "{{message}}" },
 		schema: schema$3
 	},
-	name: RULE_NAME$55,
-	create: create$55,
+	name: RULE_NAME$53,
+	create: create$53,
 	defaultOptions: defaultOptions$3
 });
-function create$55(context) {
+function create$53(context) {
 	const policy = context.options[0] ?? defaultOptions$3[0];
 	const jsx = JsxInspector.from(context);
 	const { jsxFragmentFactory } = jsx.jsxConfig;
@@ -1723,73 +1720,188 @@ function create$55(context) {
 }
 
 //#endregion
-//#region src/rules/jsx-uses-react/jsx-uses-react.ts
-const RULE_NAME$54 = "jsx-uses-react";
-var jsx_uses_react_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Marks React variables as used when JSX is present." },
-		messages: { default: "Marked {{name}} as used." },
-		schema: []
-	},
-	name: RULE_NAME$54,
-	create: create$54,
-	defaultOptions: []
-});
-function create$54(context) {
-	const { jsx, jsxFactory, jsxFragmentFactory } = JsxInspector.from(context).jsxConfig;
-	if (jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev) return {};
-	function handleJsxElement(node) {
-		context.sourceCode.markVariableAsUsed(jsxFactory, node);
-		debugReport(context, node, jsxFactory);
-	}
-	function handleJsxFragment(node) {
-		context.sourceCode.markVariableAsUsed(jsxFragmentFactory, node);
-		debugReport(context, node, jsxFragmentFactory);
+//#region ../../../.pkgs/eff/dist/index.js
+function not(predicate) {
+	return (data) => !predicate(data);
+}
+/**
+* Returns its argument.
+*
+* @param x - The value to return.
+* @returns The input value unchanged.
+*/
+function identity(x) {
+	return x;
+}
+/**
+* Creates a function that can be used in a data-last (aka `pipe`able) or
+* data-first style.
+*
+* The first parameter to `dual` is either the arity of the uncurried function
+* or a predicate that determines if the function is being used in a data-first
+* or data-last style.
+*
+* Using the arity is the most common use case, but there are some cases where
+* you may want to use a predicate. For example, if you have a function that
+* takes an optional argument, you can use a predicate to determine if the
+* function is being used in a data-first or data-last style.
+*
+* You can pass either the arity of the uncurried function or a predicate
+* which determines if the function is being used in a data-first or
+* data-last style.
+*
+* **Example** (Using arity to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = 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** (Using call signatures to define the overloads)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum: {
+*   (that: number): (self: number) => number
+*   (self: number, that: number): number
+* } = dual(2, (self: number, that: number): number => self + that)
+*
+* console.log(sum(2, 3)) // 5
+* console.log(pipe(2, sum(3))) // 5
+* ```
+*
+* **Example** (Using a predicate to determine data-first or data-last style)
+*
+* ```ts
+* import { dual, pipe } from "effect/Function"
+*
+* const sum = 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
+* ```
+*
+* @param arity - The arity of the uncurried function or a predicate that determines if the function is being used in a data-first or data-last style.
+* @param body - The function to be curried.
+* @since 1.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);
+			};
+		};
 	}
-	return defineRuleListener({
-		JSXFragment: handleJsxFragment,
-		JSXOpeningElement: handleJsxElement,
-		JSXOpeningFragment: handleJsxElement
-	});
+};
+/**
+* Do nothing and return `void`.
+*/
+function constVoid() {}
+/**
+* Do nothing and return `true`.
+*
+* @returns true
+*/
+function constTrue() {
+	return true;
 }
-function debugReport(context, node, name) {
-	if (process.env["ESLINT_REACT_DEBUG"] !== "1") return;
-	context.report({
-		data: { name },
-		messageId: "default",
-		node
-	});
+/**
+* Do nothing and return `false`.
+*
+* @returns false
+*/
+function constFalse() {
+	return false;
 }
-
-//#endregion
-//#region src/rules/jsx-uses-vars/jsx-uses-vars.ts
-const RULE_NAME$53 = "jsx-uses-vars";
-var jsx_uses_vars_default = createRule({
-	meta: {
-		type: "problem",
-		docs: { description: "Marks JSX element variables as used." },
-		messages: { default: "An identifier in JSX is marked as used." },
-		schema: []
-	},
-	name: RULE_NAME$53,
-	create: create$53,
-	defaultOptions: []
-});
-function create$53(context) {
-	return defineRuleListener({ JSXOpeningElement(node) {
-		switch (node.name.type) {
-			case AST_NODE_TYPES.JSXIdentifier:
-				if (/^[a-z]/u.test(node.name.name)) return;
-				context.sourceCode.markVariableAsUsed(node.name.name, node);
-				break;
-			case AST_NODE_TYPES.JSXMemberExpression: {
-				const { object } = node.name;
-				if (object.type === AST_NODE_TYPES.JSXIdentifier) context.sourceCode.markVariableAsUsed(object.name, node);
-				break;
-			}
-		}
-	} });
+/**
+* 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`.
+*
+* @param self - The first function to apply (or the composed function in data-last style).
+* @param bc - The second function to apply.
+* @returns A composed function that applies both functions in sequence.
+* @example
+* ```ts
+* import * as assert from "node:assert"
+* import { compose } from "effect/Function"
+*
+* const increment = (n: number) => n + 1;
+* const square = (n: number) => n * n;
+*
+* assert.strictEqual(compose(increment, square)(2), 9);
+* ```
+*
+* @since 1.0.0
+*/
+const compose = dual(2, (ab, bc) => (a) => bc(ab(a)));
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+	switch (arguments.length) {
+		case 1: return ab;
+		case 2: return function() {
+			return bc(ab.apply(this, arguments));
+		};
+		case 3: return function() {
+			return cd(bc(ab.apply(this, arguments)));
+		};
+		case 4: return function() {
+			return de(cd(bc(ab.apply(this, arguments))));
+		};
+		case 5: return function() {
+			return ef(de(cd(bc(ab.apply(this, arguments)))));
+		};
+		case 6: return function() {
+			return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+		};
+		case 7: return function() {
+			return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+		};
+		case 8: return function() {
+			return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+		};
+		case 9: return function() {
+			return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+		};
+	}
+}
+function getOrElseUpdate(map, key, callback) {
+	if (map.has(key)) return map.get(key);
+	const value = callback();
+	map.set(key, value);
+	return value;
 }
 
 //#endregion
@@ -4239,20 +4351,31 @@ function create$7(context) {
 	const nExprs = [];
 	return defineRuleListener(hCollector.visitor, cCollector.visitor, {
 		CallExpression(node) {
-			if (node.callee.type !== AST_NODE_TYPES.MemberExpression) return;
 			const expr = ast.getUnderlyingExpression(node.callee);
-			if (expr.type !== AST_NODE_TYPES.MemberExpression) return;
-			if (expr.object.type !== AST_NODE_TYPES.Identifier) return;
-			if (expr.property.type !== AST_NODE_TYPES.Identifier) return;
-			const objectName = expr.object.name;
-			const propertyName = expr.property.name;
-			if (!IMPURE_FUNCS.get(objectName)?.has(propertyName)) return;
-			const func = ast.findParentNode(node, ast.isFunction);
-			if (func == null) return;
-			cExprs.push({
-				func,
-				node
-			});
+			switch (true) {
+				case expr.type === AST_NODE_TYPES.Identifier: {
+					if (!IMPURE_FUNCS.get("globalThis")?.has(expr.name)) return;
+					const func = ast.findParentNode(node, ast.isFunction);
+					if (func == null) return;
+					cExprs.push({
+						func,
+						node
+					});
+					break;
+				}
+				case expr.type === AST_NODE_TYPES.MemberExpression && expr.object.type === AST_NODE_TYPES.Identifier && expr.property.type === AST_NODE_TYPES.Identifier: {
+					const objectName = expr.object.name;
+					const propertyName = expr.property.name;
+					if (!IMPURE_FUNCS.get(objectName)?.has(propertyName)) return;
+					const func = ast.findParentNode(node, ast.isFunction);
+					if (func == null) return;
+					cExprs.push({
+						func,
+						node
+					});
+					break;
+				}
+			}
 		},
 		NewExpression(node) {
 			const expr = ast.getUnderlyingExpression(node.callee);
@@ -7235,8 +7358,6 @@ const plugin = {
 		"jsx-no-duplicate-props": jsx_no_duplicate_props_default,
 		"jsx-shorthand-boolean": jsx_shorthand_boolean_default,
 		"jsx-shorthand-fragment": jsx_shorthand_fragment_default,
-		"jsx-uses-react": jsx_uses_react_default,
-		"jsx-uses-vars": jsx_uses_vars_default,
 		"no-access-state-in-setstate": no_access_state_in_setstate_default,
 		"no-array-index-key": no_array_index_key_default,
 		"no-children-count": no_children_count_default,
@@ -7310,8 +7431,6 @@ const rules$6 = {
 	"react-x/jsx-key-before-spread": "warn",
 	"react-x/jsx-no-comment-textnodes": "warn",
 	"react-x/jsx-no-duplicate-props": "warn",
-	"react-x/jsx-uses-react": "warn",
-	"react-x/jsx-uses-vars": "warn",
 	"react-x/no-access-state-in-setstate": "error",
 	"react-x/no-array-index-key": "warn",
 	"react-x/no-children-count": "warn",
@@ -7356,11 +7475,7 @@ const settings$5 = { "react-x": DEFAULT_ESLINT_REACT_SETTINGS };
 /**
 * Disables rules that are already handled by TypeScript
 */
-const rules$5 = {
-	"react-x/jsx-no-duplicate-props": "off",
-	"react-x/jsx-uses-react": "off",
-	"react-x/jsx-uses-vars": "off"
-};
+const rules$5 = { "react-x/jsx-no-duplicate-props": "off" };
 
 //#endregion
 //#region src/configs/recommended-typescript.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "3.0.0-next.71",
+  "version": "3.0.0-next.74",
   "description": "A set of composable ESLint rules for libraries and frameworks that use React as a UI runtime.",
   "keywords": [
     "react",
@@ -45,11 +45,11 @@
     "string-ts": "^2.3.1",
     "ts-api-utils": "^2.4.0",
     "ts-pattern": "^5.9.0",
-    "@eslint-react/ast": "3.0.0-next.71",
-    "@eslint-react/eff": "3.0.0-next.71",
-    "@eslint-react/core": "3.0.0-next.71",
-    "@eslint-react/shared": "3.0.0-next.71",
-    "@eslint-react/var": "3.0.0-next.71"
+    "@eslint-react/shared": "3.0.0-next.74",
+    "@eslint-react/var": "3.0.0-next.74",
+    "@local/eff": "3.0.0-beta.72",
+    "@eslint-react/ast": "3.0.0-next.74",
+    "@eslint-react/core": "3.0.0-next.74"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",
@@ -60,8 +60,8 @@
     "@local/configs": "0.0.0"
   },
   "peerDependencies": {
-    "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
-    "typescript": ">=4.8.4 <6.0.0"
+    "eslint": "^10.0.0",
+    "typescript": "*"
   },
   "engines": {
     "node": ">=22.0.0"