eslint-plugin-react-x 3.0.0-beta.54 → 3.0.0-beta.55

package/dist/index.js

@@ -68,7 +68,7 @@ const rules$7 = {
 //#endregion
 //#region package.json
 var name$6 = "eslint-plugin-react-x";
-var version = "3.0.0-beta.54";
+var version = "3.0.0-beta.55";
 
 //#endregion
 //#region src/utils/create-rule.ts
@@ -4225,126 +4225,6 @@ function create$6(context) {
 //#endregion
 //#region src/rules/refs/refs.ts
 const RULE_NAME$5 = "refs";
-function isWriteAccess(node) {
-	const { parent } = node;
-	if (parent.type === AST_NODE_TYPES.AssignmentExpression && parent.left === node) return true;
-	if (parent.type === AST_NODE_TYPES.UpdateExpression && parent.argument === node) return true;
-	return false;
-}
-function isInsideNestedFunction(node, boundary) {
-	let current = node.parent;
-	while (current != null && current !== boundary) {
-		if (ast.isFunction(current)) return true;
-		current = current.parent;
-	}
-	return false;
-}
-/**
-* Check if a ref.current access is part of a lazy initialization pattern.
-*
-* Standard:
-*   if (ref.current === null) { ref.current = value; }
-*
-* Inverted (with early return):
-*   if (ref.current !== null) { return ...; }
-*   ref.current = computeValue();
-* @param node The MemberExpression node for ref.current
-* @param isWrite Whether this access is a write (assignment/update) or a read
-* @returns true if this access is part of a lazy initialization pattern and should be allowed during render
-*/
-function isPartOfLazyInitialization(node, isWrite) {
-	if (node.object.type !== AST_NODE_TYPES.Identifier) return false;
-	const refName = node.object.name;
-	if (isInNullCheckTest(node)) return true;
-	if (findEnclosingRefNullCheckIf(node, refName) != null) return true;
-	if (isWrite && isWriteAfterNullCheckIf(node, refName)) return true;
-	return false;
-}
-function isNullCheckOperator(operator) {
-	return operator === "===" || operator === "==" || operator === "!==" || operator === "!=";
-}
-/**
-* Check if a test expression is a null check on `ref.current` for a given ref name.
-* @param test The test expression to check
-* @param refName The name of the ref variable (e.g. "myRef") to check against
-* @returns true if the test is of the form `ref.current === null` or `null === ref.current`
-*/
-function isRefCurrentNullCheck(test, refName) {
-	if (test.type !== AST_NODE_TYPES.BinaryExpression) return false;
-	if (!isNullCheckOperator(test.operator)) return false;
-	const { left, right } = test;
-	const isRefSide = (side) => side.type === AST_NODE_TYPES.MemberExpression && side.object.type === AST_NODE_TYPES.Identifier && side.object.name === refName && side.property.type === AST_NODE_TYPES.Identifier && side.property.name === "current";
-	const isNullSide = (side) => side.type === AST_NODE_TYPES.Literal && side.value == null;
-	return isRefSide(left) && isNullSide(right) || isRefSide(right) && isNullSide(left);
-}
-/**
-* Check if the node is the operand of a `ref.current === null` test inside an IfStatement.
-* @param node The MemberExpression node for ref.current
-* @returns true if the node is part of a null check test in an if statement
-*/
-function isInNullCheckTest(node) {
-	const { parent } = node;
-	if (parent.type !== AST_NODE_TYPES.BinaryExpression) return false;
-	if (!isNullCheckOperator(parent.operator)) return false;
-	const otherSide = parent.left === node ? parent.right : parent.left;
-	if (otherSide.type !== AST_NODE_TYPES.Literal || otherSide.value != null) return false;
-	return parent.parent.type === AST_NODE_TYPES.IfStatement && parent.parent.test === parent;
-}
-/**
-* Walk up from the node to find a containing IfStatement whose test is a null-check
-* on `ref.current` with the given ref name.
-* @param node The MemberExpression node for ref.current
-* @param refName The name of the ref variable (e.g. "myRef") to check against
-* @returns the enclosing IfStatement node if found, or null if not found
-*/
-function findEnclosingRefNullCheckIf(node, refName) {
-	let current = node.parent;
-	while (current != null) {
-		if (current.type === AST_NODE_TYPES.IfStatement) return isRefCurrentNullCheck(current.test, refName) ? current : null;
-		switch (current.type) {
-			case AST_NODE_TYPES.ExpressionStatement:
-			case AST_NODE_TYPES.BlockStatement:
-			case AST_NODE_TYPES.ReturnStatement:
-			case AST_NODE_TYPES.JSXExpressionContainer:
-			case AST_NODE_TYPES.JSXElement:
-			case AST_NODE_TYPES.JSXOpeningElement:
-			case AST_NODE_TYPES.JSXClosingElement:
-			case AST_NODE_TYPES.AssignmentExpression:
-			case AST_NODE_TYPES.VariableDeclaration:
-			case AST_NODE_TYPES.VariableDeclarator:
-			case AST_NODE_TYPES.MemberExpression:
-			case AST_NODE_TYPES.ChainExpression:
-			case AST_NODE_TYPES.CallExpression: break;
-			default: return null;
-		}
-		current = current.parent;
-	}
-	return null;
-}
-/**
-* Check if a write to `ref.current` comes after a sibling if-statement that null-checks
-* the same ref (inverted lazy init with early return pattern):
-*
-*   if (ref.current !== null) { return ...; }
-*   ref.current = value; // ← this write
-* @param node The MemberExpression node for ref.current being written to
-* @param refName The name of the ref variable (e.g. "myRef") to check against
-* @returns true if there is a preceding sibling if-statement that null-checks the same ref
-*/
-function isWriteAfterNullCheckIf(node, refName) {
-	let stmt = node;
-	while (stmt.parent != null && stmt.parent.type !== AST_NODE_TYPES.BlockStatement) stmt = stmt.parent;
-	if (stmt.parent?.type !== AST_NODE_TYPES.BlockStatement) return false;
-	const block = stmt.parent;
-	const stmtIdx = block.body.indexOf(stmt);
-	if (stmtIdx < 0) return false;
-	for (let i = stmtIdx - 1; i >= 0; i--) {
-		const sibling = block.body[i];
-		if (sibling == null) continue;
-		if (sibling.type === AST_NODE_TYPES.IfStatement && isRefCurrentNullCheck(sibling.test, refName)) return true;
-	}
-	return false;
-}
 var refs_default = createRule({
 	meta: {
 		type: "problem",
@@ -4364,34 +4244,110 @@ function create$5(context) {
 	const cCollector = core.useComponentCollector(context);
 	const refAccesses = [];
 	const jsxRefIdentifiers = /* @__PURE__ */ new Set();
-	function isRefIdentifier(node) {
-		if (node.type !== AST_NODE_TYPES.Identifier) return false;
-		if (core.isRefLikeName(node.name)) return true;
-		if (jsxRefIdentifiers.has(node.name)) return true;
-		return core.isInitializedFromRef(node.name, context.sourceCode.getScope(node));
+	/**
+	* Check if the node is the operand of a `ref.current === null` test inside an IfStatement.
+	* @param node The MemberExpression node for ref.current
+	* @returns true if the node is part of a null check test in an if statement
+	*/
+	function isInNullCheckTest(node) {
+		const { parent } = node;
+		if (!isMatching({
+			type: AST_NODE_TYPES.BinaryExpression,
+			operator: P.union("===", "==", "!==", "!=")
+		}, parent)) return false;
+		const otherSide = parent.left === node ? parent.right : parent.left;
+		if (otherSide.type !== AST_NODE_TYPES.Literal || otherSide.value != null) return false;
+		return parent.parent.type === AST_NODE_TYPES.IfStatement && parent.parent.test === parent;
+	}
+	/**
+	* Check if a test expression is a null check on `ref.current` for a given ref name.
+	* Matches forms like `ref.current === null`, `null === ref.current`, and their != variants.
+	*/
+	function isRefCurrentNullCheck(test, refName) {
+		if (test.type !== AST_NODE_TYPES.BinaryExpression) return false;
+		const op = test.operator;
+		if (op !== "===" && op !== "==" && op !== "!==" && op !== "!=") return false;
+		const { left, right } = test;
+		const checkSides = (a, b) => a.type === AST_NODE_TYPES.MemberExpression && a.object.type === AST_NODE_TYPES.Identifier && a.object.name === refName && a.property.type === AST_NODE_TYPES.Identifier && a.property.name === "current" && b.type === AST_NODE_TYPES.Literal && b.value == null;
+		return checkSides(left, right) || checkSides(right, left);
 	}
 	return defineRuleListener(hCollector.visitor, cCollector.visitor, {
 		JSXAttribute(node) {
-			if (node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.Identifier) jsxRefIdentifiers.add(node.value.expression.name);
+			switch (true) {
+				case node.name.type === AST_NODE_TYPES.JSXIdentifier && node.name.name === "ref" && node.value?.type === AST_NODE_TYPES.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES.Identifier:
+					jsxRefIdentifiers.add(node.value.expression.name);
+					return;
+			}
 		},
 		MemberExpression(node) {
-			if (node.property.type !== AST_NODE_TYPES.Identifier || node.property.name !== "current") return;
+			if (!ast.isIdentifier(node.property, "current")) return;
 			refAccesses.push({
 				node,
-				isWrite: isWriteAccess(node)
+				isWrite: match(node.parent).with({ type: AST_NODE_TYPES.AssignmentExpression }, (p) => p.left === node).with({ type: AST_NODE_TYPES.UpdateExpression }, (p) => p.argument === node).otherwise(() => false)
 			});
 		},
 		"Program:exit"(program) {
-			const components = cCollector.ctx.getAllComponents(program);
+			const comps = cCollector.ctx.getAllComponents(program);
 			const hooks = hCollector.ctx.getAllHooks(program);
-			const componentAndHookFns = new Set([...components.map((c) => c.node), ...hooks.map((h) => h.node)]);
-			const isComponentOrHookFn = (n) => ast.isFunction(n) && componentAndHookFns.has(n);
+			const funcs = new Set([...comps.map((c) => c.node), ...hooks.map((h) => h.node)]);
+			const isCompOrHookFn = (n) => ast.isFunction(n) && funcs.has(n);
 			for (const { node, isWrite } of refAccesses) {
-				if (!isRefIdentifier(node.object)) continue;
-				const boundary = ast.findParentNode(node, isComponentOrHookFn);
+				const obj = node.object;
+				if (obj.type !== AST_NODE_TYPES.Identifier) continue;
+				switch (true) {
+					case core.isRefLikeName(obj.name):
+					case jsxRefIdentifiers.has(obj.name):
+					case core.isInitializedFromRef(obj.name, context.sourceCode.getScope(node.object)): break;
+					default: continue;
+				}
+				const boundary = ast.findParentNode(node, isCompOrHookFn);
 				if (boundary == null) continue;
-				if (isInsideNestedFunction(node, boundary)) continue;
-				if (isPartOfLazyInitialization(node, isWrite)) continue;
+				if (ast.findParentNode(node, ast.isFunction) !== boundary) continue;
+				const refName = obj.name;
+				let isLazyInit = isInNullCheckTest(node);
+				if (!isLazyInit) {
+					let current = node.parent;
+					findIf: while (current != null) {
+						if (current.type === AST_NODE_TYPES.IfStatement) {
+							if (isRefCurrentNullCheck(current.test, refName)) isLazyInit = true;
+							break;
+						}
+						switch (current.type) {
+							case AST_NODE_TYPES.ExpressionStatement:
+							case AST_NODE_TYPES.BlockStatement:
+							case AST_NODE_TYPES.ReturnStatement:
+							case AST_NODE_TYPES.JSXExpressionContainer:
+							case AST_NODE_TYPES.JSXElement:
+							case AST_NODE_TYPES.JSXOpeningElement:
+							case AST_NODE_TYPES.JSXClosingElement:
+							case AST_NODE_TYPES.AssignmentExpression:
+							case AST_NODE_TYPES.VariableDeclaration:
+							case AST_NODE_TYPES.VariableDeclarator:
+							case AST_NODE_TYPES.MemberExpression:
+							case AST_NODE_TYPES.ChainExpression:
+							case AST_NODE_TYPES.CallExpression: break;
+							default: break findIf;
+						}
+						current = current.parent;
+					}
+				}
+				if (!isLazyInit && isWrite) {
+					let stmt = node;
+					while (stmt.parent != null && stmt.parent.type !== AST_NODE_TYPES.BlockStatement) stmt = stmt.parent;
+					if (stmt.parent?.type === AST_NODE_TYPES.BlockStatement) {
+						const block = stmt.parent;
+						const stmtIdx = block.body.indexOf(stmt);
+						if (stmtIdx >= 0) for (let i = stmtIdx - 1; i >= 0; i--) {
+							const sibling = block.body[i];
+							if (sibling == null) continue;
+							if (sibling.type === AST_NODE_TYPES.IfStatement && isRefCurrentNullCheck(sibling.test, refName)) {
+								isLazyInit = true;
+								break;
+							}
+						}
+					}
+				}
+				if (isLazyInit) continue;
 				context.report({
 					messageId: isWrite ? "writeDuringRender" : "readDuringRender",
 					node

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-x",
-  "version": "3.0.0-beta.54",
+  "version": "3.0.0-beta.55",
   "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-beta.54",
-    "@eslint-react/core": "3.0.0-beta.54",
-    "@eslint-react/eff": "3.0.0-beta.54",
-    "@eslint-react/var": "3.0.0-beta.54",
-    "@eslint-react/shared": "3.0.0-beta.54"
+    "@eslint-react/eff": "3.0.0-beta.55",
+    "@eslint-react/core": "3.0.0-beta.55",
+    "@eslint-react/ast": "3.0.0-beta.55",
+    "@eslint-react/shared": "3.0.0-beta.55",
+    "@eslint-react/var": "3.0.0-beta.55"
   },
   "devDependencies": {
     "@types/react": "^19.2.14",