eslint-plugin-react-naming-convention 5.26.2 → 5.26.4

package/dist/index.js

@@ -1,10 +1,8 @@
 import * as ESLintUtils from "@typescript-eslint/utils/eslint-utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import * as core from "@eslint-react/core";
 import "@eslint-react/eslint";
-import { resolveEnclosingAssignmentTarget } from "@eslint-react/var";
-import { AST_NODE_TYPES } from "@typescript-eslint/types";
-import { P, match } from "ts-pattern";
-import { Extract } from "@eslint-react/ast";
+import { Check } from "@eslint-react/ast";
 import { getSettingsFromContext } from "@eslint-react/shared";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -20,13 +18,74 @@ var __exportAll = (all, no_symbols) => {
 //#endregion
 //#region package.json
 var name$1 = "eslint-plugin-react-naming-convention";
-var version = "5.26.2";
+var version = "5.26.4";
 //#endregion
 //#region src/utils/create-rule.ts
 function getDocsUrl(ruleName) {
 	return `https://eslint-react.xyz/docs/rules/naming-convention-${ruleName}`;
 }
 const createRule = ESLintUtils.RuleCreator(getDocsUrl);
+//#endregion
+//#region src/utils/resolve-naming-target.ts
+function resolveNamingTarget(node) {
+	return resolveUpward(node, null);
+}
+function resolveUpward(node, propertyTarget) {
+	const parent = node.parent;
+	if (parent == null) return null;
+	if (parent.type === AST_NODE_TYPES.Property) {
+		if (parent.value !== node) return null;
+		const keyTarget = getKeyTarget(parent.key, parent.computed);
+		if (keyTarget == null) return null;
+		propertyTarget ??= keyTarget;
+		return resolveUpward(parent, propertyTarget);
+	}
+	switch (parent.type) {
+		case AST_NODE_TYPES.VariableDeclarator: {
+			const idTarget = getIdentifierTarget(parent.id);
+			return idTarget == null ? null : propertyTarget ?? idTarget;
+		}
+		case AST_NODE_TYPES.AssignmentExpression: {
+			const leftTarget = getAssignmentTarget(parent.left);
+			return leftTarget == null ? null : propertyTarget ?? leftTarget;
+		}
+		case AST_NODE_TYPES.PropertyDefinition: {
+			const keyTarget = getKeyTarget(parent.key, parent.computed);
+			return keyTarget == null ? null : propertyTarget ?? keyTarget;
+		}
+		case AST_NODE_TYPES.ConditionalExpression:
+		case AST_NODE_TYPES.LogicalExpression:
+		case AST_NODE_TYPES.AwaitExpression:
+		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:
+		case AST_NODE_TYPES.ObjectExpression: return resolveUpward(parent, propertyTarget);
+		case AST_NODE_TYPES.SequenceExpression: return parent.expressions[parent.expressions.length - 1] === node ? resolveUpward(parent, propertyTarget) : null;
+		case AST_NODE_TYPES.CallExpression:
+		case AST_NODE_TYPES.NewExpression: return parent.arguments.some((argument) => argument === node) ? resolveUpward(parent, propertyTarget) : null;
+		default: return null;
+	}
+}
+function getStaticName(key, computed) {
+	if (!computed && key.type === AST_NODE_TYPES.Identifier) return key.name;
+	if (key.type === AST_NODE_TYPES.Literal && typeof key.value === "string") return key.value;
+	return null;
+}
+function getIdentifierTarget(node) {
+	return node.type === AST_NODE_TYPES.Identifier ? [node, node.name] : null;
+}
+function getAssignmentTarget(left) {
+	if (left.type === AST_NODE_TYPES.Identifier) return [left, left.name];
+	if (left.type === AST_NODE_TYPES.MemberExpression) return getKeyTarget(left.property, left.computed, left);
+	return null;
+}
+function getKeyTarget(key, computed, reportNode = key) {
+	const name = getStaticName(key, computed);
+	return name == null ? null : [reportNode, name];
+}
 var context_name_default = createRule({
 	meta: {
 		type: "suggestion",
@@ -41,14 +100,9 @@ function create$2(context) {
 	if (!context.sourceCode.text.includes("createContext")) return {};
 	return { CallExpression(node) {
 		if (!core.isCreateContextCall(context, node)) return;
-		const [id, name] = match(resolveEnclosingAssignmentTarget(node)).with({
-			type: AST_NODE_TYPES.Identifier,
-			name: P.string
-		}, (id) => [id, id.name]).with({
-			type: AST_NODE_TYPES.MemberExpression,
-			property: { name: P.string }
-		}, (id) => [id, id.property.name]).otherwise(() => [null, null]);
-		if (id == null) return;
+		const target = resolveNamingTarget(node);
+		if (target == null) return;
+		const [id, name] = target;
 		if (core.isFunctionComponentName(name) && name.endsWith("Context")) return;
 		context.report({
 			messageId: "invalid-context-name",
@@ -70,14 +124,9 @@ function create$1(context) {
 	if (!context.sourceCode.text.includes("useId")) return {};
 	return { CallExpression(node) {
 		if (!core.isUseIdCall(context, node)) return;
-		const [id, name] = match(resolveEnclosingAssignmentTarget(node)).with({
-			type: AST_NODE_TYPES.Identifier,
-			name: P.string
-		}, (id) => [id, id.name]).with({
-			type: AST_NODE_TYPES.MemberExpression,
-			property: { name: P.string }
-		}, (id) => [id, id.property.name]).otherwise(() => [null, null]);
-		if (id == null) return;
+		const target = resolveNamingTarget(node);
+		if (target == null) return;
+		const [id, name] = target;
 		if (name.endsWith("Id") || name === "id") return;
 		context.report({
 			messageId: "invalid-id-name",
@@ -99,15 +148,12 @@ function create(context) {
 	const { additionalRefHooks } = getSettingsFromContext(context);
 	return { CallExpression(node) {
 		if (!core.isUseRefLikeCall(node, additionalRefHooks)) return;
-		if (Extract.unwrap(node.parent).type === AST_NODE_TYPES.MemberExpression) return;
-		const [id, name] = match(resolveEnclosingAssignmentTarget(node)).with({
-			type: AST_NODE_TYPES.Identifier,
-			name: P.string
-		}, (id) => [id, id.name]).with({
-			type: AST_NODE_TYPES.MemberExpression,
-			property: { name: P.string }
-		}, (id) => [id, id.property.name]).otherwise(() => [null, null]);
-		if (id == null) return;
+		let parent = node.parent;
+		while (Check.isTypeExpression(parent)) parent = parent.parent;
+		if (parent.type === AST_NODE_TYPES.MemberExpression) return;
+		const target = resolveNamingTarget(node);
+		if (target == null) return;
+		const [id, name] = target;
 		if (name.endsWith("Ref") || name === "ref") return;
 		context.report({
 			messageId: "invalid-ref-name",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-react-naming-convention",
-  "version": "5.26.2",
+  "version": "5.26.4",
   "description": "ESLint React's ESLint plugin for naming convention related rules.",
   "keywords": [
     "react",
@@ -37,13 +37,13 @@
     "dist"
   ],
   "dependencies": {
-    "@eslint-react/ast": "5.26.2",
-    "@eslint-react/core": "5.26.2",
-    "@eslint-react/eslint": "5.26.2",
-    "@eslint-react/shared": "5.26.2",
-    "@eslint-react/var": "5.26.2",
-    "@typescript-eslint/types": "^8.71.1",
-    "@typescript-eslint/utils": "^8.71.1",
+    "@eslint-react/ast": "5.26.4",
+    "@eslint-react/core": "5.26.4",
+    "@eslint-react/eslint": "5.26.4",
+    "@eslint-react/shared": "5.26.4",
+    "@eslint-react/var": "5.26.4",
+    "@typescript-eslint/types": "^8.71.2",
+    "@typescript-eslint/utils": "^8.71.2",
     "ts-pattern": "^5.9.0"
   },
   "devDependencies": {