eslint-plugin-zod 4.9.1 → 4.10.0

package/README.md

@@ -67,6 +67,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [prefer-meta-last](docs/rules/prefer-meta-last.md)                                               | Enforce `.meta()` as last method                                                                                               | ✅  | 🔧  |     |     |
 | [prefer-nullish](docs/rules/prefer-nullish.md)                                                   | Enforce `.nullish()` instead of combining `.optional()` and `.nullable()`                                                      | ✅  | 🔧  |     |     |
 | [prefer-strict-object](docs/rules/prefer-strict-object.md)                                       | Prefer `z.strictObject()` over `z.object().strict()`                                                                           | ✅  | 🔧  |     |     |
+| [prefer-string-length-over-min-max](docs/rules/prefer-string-length-over-min-max.md)             | Prefer `.length(n)` over `.min(n).max(n)` with the same value on a string schema                                               |     | 🔧  |     |     |
 | [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)                   | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |     |
 | [prefer-top-level-string-formats](docs/rules/prefer-top-level-string-formats.md)                 | Prefer top-level string format schemas over deprecated `z.string().<format>()` methods                                         | ✅  | 🔧  |     |     |
 | [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |

package/dist/index.cjs

@@ -32,6 +32,7 @@ const require_prefer_meta_last = require("./rules/prefer-meta-last.cjs");
 const require_prefer_meta = require("./rules/prefer-meta.cjs");
 const require_prefer_nullish = require("./rules/prefer-nullish.cjs");
 const require_prefer_strict_object = require("./rules/prefer-strict-object.cjs");
+const require_prefer_string_length_over_min_max = require("./rules/prefer-string-length-over-min-max.cjs");
 const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
 const require_prefer_top_level_string_formats = require("./rules/prefer-top-level-string-formats.cjs");
 const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.cjs");
@@ -79,6 +80,7 @@ const eslintPluginZod = {
 		"prefer-meta-last": require_prefer_meta_last.preferMetaLast,
 		"prefer-nullish": require_prefer_nullish.preferNullish,
 		"prefer-strict-object": require_prefer_strict_object.preferStrictObject,
+		"prefer-string-length-over-min-max": require_prefer_string_length_over_min_max.preferStringLengthOverMinMax,
 		"prefer-top-level-string-formats": require_prefer_top_level_string_formats.preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,

package/dist/index.mjs

@@ -32,6 +32,7 @@ import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
 import { preferMeta } from "./rules/prefer-meta.mjs";
 import { preferNullish } from "./rules/prefer-nullish.mjs";
 import { preferStrictObject } from "./rules/prefer-strict-object.mjs";
+import { preferStringLengthOverMinMax } from "./rules/prefer-string-length-over-min-max.mjs";
 import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
 import { preferTopLevelStringFormats } from "./rules/prefer-top-level-string-formats.mjs";
 import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.mjs";
@@ -79,6 +80,7 @@ const eslintPluginZod = {
 		"prefer-meta-last": preferMetaLast,
 		"prefer-nullish": preferNullish,
 		"prefer-strict-object": preferStrictObject,
+		"prefer-string-length-over-min-max": preferStringLengthOverMinMax,
 		"prefer-top-level-string-formats": preferTopLevelStringFormats,
 		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,

package/dist/rules/no-native-enum.cjs

@@ -1,6 +1,6 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
-let _typescript_eslint_utils = require("@typescript-eslint/utils");
+let _eslint_zod_utils_rule_builders_no_native_enum = require("@eslint-zod/utils/rule-builders/no-native-enum");
 //#region src/rules/no-native-enum.ts
 const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
 	name: "no-native-enum",
@@ -12,23 +12,7 @@ const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "nativeEnum",
-			onSchema(node) {
-				const rootMethodNode = collectZodChainMethods(node).at(0)?.node;
-				context.report({
-					node,
-					messageId: "useEnum",
-					fix(fixer) {
-						if (rootMethodNode?.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
-						return fixer.replaceText(rootMethodNode.callee.property, "enum");
-					}
-				});
-			}
-		});
-	}
+	create: (0, _eslint_zod_utils_rule_builders_no_native_enum.buildNoNativeEnumCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.noNativeEnum = noNativeEnum;

package/dist/rules/no-native-enum.mjs

@@ -1,6 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
 import { zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { buildNoNativeEnumCreate } from "@eslint-zod/utils/rule-builders/no-native-enum";
 //#region src/rules/no-native-enum.ts
 const noNativeEnum = createZodPluginRule({
 	name: "no-native-enum",
@@ -12,23 +12,7 @@ const noNativeEnum = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "nativeEnum",
-			onSchema(node) {
-				const rootMethodNode = collectZodChainMethods(node).at(0)?.node;
-				context.report({
-					node,
-					messageId: "useEnum",
-					fix(fixer) {
-						if (rootMethodNode?.callee.type !== AST_NODE_TYPES.MemberExpression) return null;
-						return fixer.replaceText(rootMethodNode.callee.property, "enum");
-					}
-				});
-			}
-		});
-	}
+	create: buildNoNativeEnumCreate(zodImportScope)
 });
 //#endregion
 export { noNativeEnum };

package/dist/rules/no-promise-schema.cjs

@@ -1,5 +1,6 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_builders_no_promise_schema = require("@eslint-zod/utils/rule-builders/no-promise-schema");
 //#region src/rules/no-promise-schema.ts
 const noPromiseSchema = require_create_plugin_rule.createZodPluginRule({
 	name: "no-promise-schema",
@@ -10,18 +11,7 @@ const noPromiseSchema = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { createSchemaVisitor } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "promise",
-			onSchema(node) {
-				context.report({
-					node,
-					messageId: "noPromiseSchema"
-				});
-			}
-		});
-	}
+	create: (0, _eslint_zod_utils_rule_builders_no_promise_schema.buildNoPromiseSchemaCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.noPromiseSchema = noPromiseSchema;

package/dist/rules/no-promise-schema.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
 import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoPromiseSchemaCreate } from "@eslint-zod/utils/rule-builders/no-promise-schema";
 //#region src/rules/no-promise-schema.ts
 const noPromiseSchema = createZodPluginRule({
 	name: "no-promise-schema",
@@ -10,18 +11,7 @@ const noPromiseSchema = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { createSchemaVisitor } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "promise",
-			onSchema(node) {
-				context.report({
-					node,
-					messageId: "noPromiseSchema"
-				});
-			}
-		});
-	}
+	create: buildNoPromiseSchemaCreate(zodImportScope)
 });
 //#endregion
 export { noPromiseSchema };

package/dist/rules/prefer-string-length-over-min-max.cjs

@@ -0,0 +1,23 @@
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
+let _eslint_zod_utils_rule_patterns_collapse_equal_bounds = require("@eslint-zod/utils/rule-patterns/collapse-equal-bounds");
+//#region src/rules/prefer-string-length-over-min-max.ts
+const preferStringLengthOverMinMax = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-string-length-over-min-max",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `.length(n)` over `.min(n).max(n)` with the same value on a string schema" },
+		messages: { preferStringLength: "Use `.length(n)` instead of `.min(n)` and `.max(n)` with the same value." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (0, _eslint_zod_utils_rule_patterns_collapse_equal_bounds.buildCollapseEqualBoundsCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		baseTypes: ["string"],
+		domain: "length",
+		messageId: "preferStringLength"
+	})
+});
+//#endregion
+exports.preferStringLengthOverMinMax = preferStringLengthOverMinMax;

package/dist/rules/prefer-string-length-over-min-max.mjs

@@ -0,0 +1,23 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildCollapseEqualBoundsCreate } from "@eslint-zod/utils/rule-patterns/collapse-equal-bounds";
+//#region src/rules/prefer-string-length-over-min-max.ts
+const preferStringLengthOverMinMax = createZodPluginRule({
+	name: "prefer-string-length-over-min-max",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `.length(n)` over `.min(n).max(n)` with the same value on a string schema" },
+		messages: { preferStringLength: "Use `.length(n)` instead of `.min(n)` and `.max(n)` with the same value." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildCollapseEqualBoundsCreate({
+		scope: zodImportScope,
+		baseTypes: ["string"],
+		domain: "length",
+		messageId: "preferStringLength"
+	})
+});
+//#endregion
+export { preferStringLengthOverMinMax };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.9.1",
+  "version": "4.10.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -38,18 +38,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "^8.62.0",
-    "@eslint-zod/utils": "3.0.0"
+    "@typescript-eslint/utils": "^8.67.0",
+    "@eslint-zod/utils": "3.1.0"
   },
   "devDependencies": {
-    "@marcalexiei/prettier-config": "2.0.0",
-    "@typescript-eslint/rule-tester": "8.65.0",
+    "@typescript-eslint/rule-tester": "8.67.0",
     "dedent": "1.7.2",
     "eslint-doc-generator": "3.7.0",
-    "prettier": "3.9.6",
     "tsdown": "0.22.14",
-    "vitest": "4.1.10",
-    "@eslint-zod/test-utils": "0.0.0"
+    "vitest": "4.1.11",
+    "@eslint-zod/tooling": "0.0.0"
   },
   "peerDependencies": {
     "eslint": "^9 || ^10",