eslint-plugin-zod 4.9.1 → 4.11.0

package/README.md

@@ -63,10 +63,12 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-unnecessary-readonly](docs/rules/no-unnecessary-readonly.md)                                 | Disallow `.readonly()` on schemas whose output is already immutable                                                            |     | 🔧  |     |     |
 | [prefer-enum-over-literal-union](docs/rules/prefer-enum-over-literal-union.md)                   | Prefer `z.enum()` over `z.union()` when all members are string literals.                                                       | ✅  | 🔧  |     |     |
 | [prefer-loose-object](docs/rules/prefer-loose-object.md)                                         | Prefer `z.looseObject()` over `z.object().passthrough()` and `z.object().loose()`                                              | ✅  | 🔧  |     |     |
+| [prefer-map-set-size-over-min-max](docs/rules/prefer-map-set-size-over-min-max.md)               | Prefer `.size(n)` over `.min(n).max(n)` with the same value on a set or map schema                                             |     | 🔧  |     |     |
 | [prefer-meta](docs/rules/prefer-meta.md)                                                         | Enforce usage of `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |     |
 | [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

@@ -28,10 +28,12 @@ const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
 const require_no_unnecessary_readonly = require("./rules/no-unnecessary-readonly.cjs");
 const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
 const require_prefer_loose_object = require("./rules/prefer-loose-object.cjs");
+const require_prefer_map_set_size_over_min_max = require("./rules/prefer-map-set-size-over-min-max.cjs");
 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");
@@ -75,10 +77,12 @@ const eslintPluginZod = {
 		"no-unnecessary-readonly": require_no_unnecessary_readonly.noUnnecessaryReadonly,
 		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
 		"prefer-loose-object": require_prefer_loose_object.preferLooseObject,
+		"prefer-map-set-size-over-min-max": require_prefer_map_set_size_over_min_max.preferMapSetSizeOverMinMax,
 		"prefer-meta": require_prefer_meta.preferMeta,
 		"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

@@ -28,10 +28,12 @@ import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
 import { noUnnecessaryReadonly } from "./rules/no-unnecessary-readonly.mjs";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
 import { preferLooseObject } from "./rules/prefer-loose-object.mjs";
+import { preferMapSetSizeOverMinMax } from "./rules/prefer-map-set-size-over-min-max.mjs";
 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";
@@ -75,10 +77,12 @@ const eslintPluginZod = {
 		"no-unnecessary-readonly": noUnnecessaryReadonly,
 		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
 		"prefer-loose-object": preferLooseObject,
+		"prefer-map-set-size-over-min-max": preferMapSetSizeOverMinMax,
 		"prefer-meta": preferMeta,
 		"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-number-schema-with-int.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_patterns_prefer_top_level_factory = require("@eslint-zod/utils/rule-patterns/prefer-top-level-factory");
 //#region src/rules/no-number-schema-with-int.ts
 const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-int",
@@ -11,34 +12,15 @@ const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "number",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const intIndex = methods.findIndex((m) => m.name === "int");
-				if (intIndex === -1) return;
-				const numberIndex = methods.findIndex((m) => m.name === "number");
-				context.report({
-					node,
-					messageId: "removeNumber",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: numberIndex,
-							toIndex: intIndex,
-							toMethodName: "int"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: (0, _eslint_zod_utils_rule_patterns_prefer_top_level_factory.buildPreferTopLevelFactoryCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		factoryName: "number",
+		replacements: [{
+			sourceMethodName: "int",
+			replacementMethodName: "int"
+		}],
+		messageId: "removeNumber"
+	})
 });
 //#endregion
 exports.noNumberSchemaWithInt = noNumberSchemaWithInt;

package/dist/rules/no-number-schema-with-int.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { buildZodChainReplacementFix, zodImportScope } from "@eslint-zod/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildPreferTopLevelFactoryCreate } from "@eslint-zod/utils/rule-patterns/prefer-top-level-factory";
 //#region src/rules/no-number-schema-with-int.ts
 const noNumberSchemaWithInt = createZodPluginRule({
 	name: "no-number-schema-with-int",
@@ -11,34 +12,15 @@ const noNumberSchemaWithInt = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "number",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const intIndex = methods.findIndex((m) => m.name === "int");
-				if (intIndex === -1) return;
-				const numberIndex = methods.findIndex((m) => m.name === "number");
-				context.report({
-					node,
-					messageId: "removeNumber",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return buildZodChainReplacementFix({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: numberIndex,
-							toIndex: intIndex,
-							toMethodName: "int"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: buildPreferTopLevelFactoryCreate({
+		scope: zodImportScope,
+		factoryName: "number",
+		replacements: [{
+			sourceMethodName: "int",
+			replacementMethodName: "int"
+		}],
+		messageId: "removeNumber"
+	})
 });
 //#endregion
 export { noNumberSchemaWithInt };

package/dist/rules/no-number-schema-with-safe.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_patterns_prefer_top_level_factory = require("@eslint-zod/utils/rule-patterns/prefer-top-level-factory");
 //#region src/rules/no-number-schema-with-safe.ts
 const noNumberSchemaWithSafe = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-safe",
@@ -11,33 +12,15 @@ const noNumberSchemaWithSafe = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "number",
-			onSchema(node, zodSchemaMeta) {
-				if (!(0, _eslint_zod_utils.getZodChainedMethodNames)(zodSchemaMeta).includes("safe")) return;
-				const methods = collectZodChainMethods(node);
-				const safeIndex = methods.findIndex((m, index) => index > 0 && m.name === "safe");
-				context.report({
-					node,
-					messageId: "useInt",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named" || safeIndex === -1) return null;
-						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: 0,
-							toIndex: safeIndex,
-							toMethodName: "int"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: (0, _eslint_zod_utils_rule_patterns_prefer_top_level_factory.buildPreferTopLevelFactoryCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		factoryName: "number",
+		replacements: [{
+			sourceMethodName: "safe",
+			replacementMethodName: "int"
+		}],
+		messageId: "useInt"
+	})
 });
 //#endregion
 exports.noNumberSchemaWithSafe = noNumberSchemaWithSafe;

package/dist/rules/no-number-schema-with-safe.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { buildZodChainReplacementFix, getZodChainedMethodNames, zodImportScope } from "@eslint-zod/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildPreferTopLevelFactoryCreate } from "@eslint-zod/utils/rule-patterns/prefer-top-level-factory";
 //#region src/rules/no-number-schema-with-safe.ts
 const noNumberSchemaWithSafe = createZodPluginRule({
 	name: "no-number-schema-with-safe",
@@ -11,33 +12,15 @@ const noNumberSchemaWithSafe = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "number",
-			onSchema(node, zodSchemaMeta) {
-				if (!getZodChainedMethodNames(zodSchemaMeta).includes("safe")) return;
-				const methods = collectZodChainMethods(node);
-				const safeIndex = methods.findIndex((m, index) => index > 0 && m.name === "safe");
-				context.report({
-					node,
-					messageId: "useInt",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named" || safeIndex === -1) return null;
-						return buildZodChainReplacementFix({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: 0,
-							toIndex: safeIndex,
-							toMethodName: "int"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: buildPreferTopLevelFactoryCreate({
+		scope: zodImportScope,
+		factoryName: "number",
+		replacements: [{
+			sourceMethodName: "safe",
+			replacementMethodName: "int"
+		}],
+		messageId: "useInt"
+	})
 });
 //#endregion
 export { noNumberSchemaWithSafe };

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/no-string-schema-with-uuid.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_patterns_prefer_top_level_factory = require("@eslint-zod/utils/rule-patterns/prefer-top-level-factory");
 //#region src/rules/no-string-schema-with-uuid.ts
 const noStringSchemaWithUuid = require_create_plugin_rule.createZodPluginRule({
 	name: "no-string-schema-with-uuid",
@@ -15,34 +16,15 @@ const noStringSchemaWithUuid = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "string",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const uuidIndex = methods.findIndex((m) => m.name === "uuid");
-				if (uuidIndex === -1) return;
-				const stringIndex = methods.findIndex((m) => m.name === "string");
-				context.report({
-					node,
-					messageId: "useUuid",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: stringIndex,
-							toIndex: uuidIndex,
-							toMethodName: "uuid"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: (0, _eslint_zod_utils_rule_patterns_prefer_top_level_factory.buildPreferTopLevelFactoryCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		factoryName: "string",
+		replacements: [{
+			sourceMethodName: "uuid",
+			replacementMethodName: "uuid"
+		}],
+		messageId: "useUuid"
+	})
 });
 //#endregion
 exports.noStringSchemaWithUuid = noStringSchemaWithUuid;

package/dist/rules/no-string-schema-with-uuid.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { buildZodChainReplacementFix, zodImportScope } from "@eslint-zod/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildPreferTopLevelFactoryCreate } from "@eslint-zod/utils/rule-patterns/prefer-top-level-factory";
 //#region src/rules/no-string-schema-with-uuid.ts
 const noStringSchemaWithUuid = createZodPluginRule({
 	name: "no-string-schema-with-uuid",
@@ -15,34 +16,15 @@ const noStringSchemaWithUuid = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { sourceCode } = context;
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "string",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const uuidIndex = methods.findIndex((m) => m.name === "uuid");
-				if (uuidIndex === -1) return;
-				const stringIndex = methods.findIndex((m) => m.name === "string");
-				context.report({
-					node,
-					messageId: "useUuid",
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return buildZodChainReplacementFix({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: stringIndex,
-							toIndex: uuidIndex,
-							toMethodName: "uuid"
-						});
-					}
-				});
-			}
-		});
-	}
+	create: buildPreferTopLevelFactoryCreate({
+		scope: zodImportScope,
+		factoryName: "string",
+		replacements: [{
+			sourceMethodName: "uuid",
+			replacementMethodName: "uuid"
+		}],
+		messageId: "useUuid"
+	})
 });
 //#endregion
 export { noStringSchemaWithUuid };

package/dist/rules/prefer-map-set-size-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-map-set-size-over-min-max.ts
+const preferMapSetSizeOverMinMax = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-map-set-size-over-min-max",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `.size(n)` over `.min(n).max(n)` with the same value on a set or map schema" },
+		messages: { preferMapSetSize: "Use `.size(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: ["set", "map"],
+		domain: "size",
+		messageId: "preferMapSetSize"
+	})
+});
+//#endregion
+exports.preferMapSetSizeOverMinMax = preferMapSetSizeOverMinMax;

package/dist/rules/prefer-map-set-size-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-map-set-size-over-min-max.ts
+const preferMapSetSizeOverMinMax = createZodPluginRule({
+	name: "prefer-map-set-size-over-min-max",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: { description: "Prefer `.size(n)` over `.min(n).max(n)` with the same value on a set or map schema" },
+		messages: { preferMapSetSize: "Use `.size(n)` instead of `.min(n)` and `.max(n)` with the same value." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: buildCollapseEqualBoundsCreate({
+		scope: zodImportScope,
+		baseTypes: ["set", "map"],
+		domain: "size",
+		messageId: "preferMapSetSize"
+	})
+});
+//#endregion
+export { preferMapSetSizeOverMinMax };

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/dist/rules/prefer-top-level-string-formats.cjs

@@ -1,12 +1,9 @@
 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_prefer_top_level_factory = require("@eslint-zod/utils/rule-patterns/prefer-top-level-factory");
 //#region src/rules/prefer-top-level-string-formats.ts
 const TOP_LEVEL_STRING_FORMATS_URL = "https://zod.dev/v4?id=top-level-string-formats";
 const ZOD_STRING_FORMAT_METHOD_NAMES = _eslint_zod_utils.ZOD_STRING_FORMAT_METHODS.map(({ sourceMethodName }) => sourceMethodName);
-const ZOD_STRING_FORMAT_METHODS_BY_SOURCE = Object.fromEntries(_eslint_zod_utils.ZOD_STRING_FORMAT_METHODS.map((format) => [format.sourceMethodName, format]));
-function isZodStringFormatMethodName(value) {
-	return ZOD_STRING_FORMAT_METHOD_NAMES.includes(value);
-}
 const preferTopLevelStringFormats = require_create_plugin_rule.createZodPluginRule({
 	name: "prefer-top-level-string-formats",
 	meta: {
@@ -33,39 +30,13 @@ const preferTopLevelStringFormats = require_create_plugin_rule.createZodPluginRu
 	},
 	defaultOptions: [{}],
 	create(context, [{ ignore = [] }]) {
-		const { sourceCode } = context;
-		const ignoredMethods = new Set(ignore);
-		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "string",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const stringIndex = methods.findIndex((method) => method.name === "string");
-				if (stringIndex === -1) return;
-				const formatMethod = methods.find((method, index) => index > stringIndex && isZodStringFormatMethodName(method.name) && !ignoredMethods.has(method.name));
-				if (!formatMethod) return;
-				const { replacementMethodName, sourceMethodName } = ZOD_STRING_FORMAT_METHODS_BY_SOURCE[formatMethod.name];
-				context.report({
-					node,
-					messageId: "preferTopLevelStringFormat",
-					data: {
-						replacementMethod: replacementMethodName,
-						sourceMethod: sourceMethodName
-					},
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return (0, _eslint_zod_utils.buildZodChainReplacementFix)({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: stringIndex,
-							toIndex: methods.indexOf(formatMethod),
-							toMethodName: replacementMethodName
-						});
-					}
-				});
-			}
-		});
+		return (0, _eslint_zod_utils_rule_patterns_prefer_top_level_factory.buildPreferTopLevelFactoryCreate)({
+			scope: _eslint_zod_utils.zodImportScope,
+			factoryName: "string",
+			replacements: _eslint_zod_utils.ZOD_STRING_FORMAT_METHODS,
+			messageId: "preferTopLevelStringFormat",
+			ignore
+		})(context);
 	}
 });
 //#endregion

package/dist/rules/prefer-top-level-string-formats.mjs

@@ -1,12 +1,9 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { ZOD_STRING_FORMAT_METHODS, buildZodChainReplacementFix, zodImportScope } from "@eslint-zod/utils";
+import { ZOD_STRING_FORMAT_METHODS, zodImportScope } from "@eslint-zod/utils";
+import { buildPreferTopLevelFactoryCreate } from "@eslint-zod/utils/rule-patterns/prefer-top-level-factory";
 //#region src/rules/prefer-top-level-string-formats.ts
 const TOP_LEVEL_STRING_FORMATS_URL = "https://zod.dev/v4?id=top-level-string-formats";
 const ZOD_STRING_FORMAT_METHOD_NAMES = ZOD_STRING_FORMAT_METHODS.map(({ sourceMethodName }) => sourceMethodName);
-const ZOD_STRING_FORMAT_METHODS_BY_SOURCE = Object.fromEntries(ZOD_STRING_FORMAT_METHODS.map((format) => [format.sourceMethodName, format]));
-function isZodStringFormatMethodName(value) {
-	return ZOD_STRING_FORMAT_METHOD_NAMES.includes(value);
-}
 const preferTopLevelStringFormats = createZodPluginRule({
 	name: "prefer-top-level-string-formats",
 	meta: {
@@ -33,39 +30,13 @@ const preferTopLevelStringFormats = createZodPluginRule({
 	},
 	defaultOptions: [{}],
 	create(context, [{ ignore = [] }]) {
-		const { sourceCode } = context;
-		const ignoredMethods = new Set(ignore);
-		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
-		return createSchemaVisitor({
-			schemaType: "string",
-			onSchema(node, zodSchemaMeta) {
-				const methods = collectZodChainMethods(node);
-				const stringIndex = methods.findIndex((method) => method.name === "string");
-				if (stringIndex === -1) return;
-				const formatMethod = methods.find((method, index) => index > stringIndex && isZodStringFormatMethodName(method.name) && !ignoredMethods.has(method.name));
-				if (!formatMethod) return;
-				const { replacementMethodName, sourceMethodName } = ZOD_STRING_FORMAT_METHODS_BY_SOURCE[formatMethod.name];
-				context.report({
-					node,
-					messageId: "preferTopLevelStringFormat",
-					data: {
-						replacementMethod: replacementMethodName,
-						sourceMethod: sourceMethodName
-					},
-					fix(fixer) {
-						if (zodSchemaMeta.schemaDecl === "named") return null;
-						return buildZodChainReplacementFix({
-							sourceCode,
-							fixer,
-							methods,
-							fromIndex: stringIndex,
-							toIndex: methods.indexOf(formatMethod),
-							toMethodName: replacementMethodName
-						});
-					}
-				});
-			}
-		});
+		return buildPreferTopLevelFactoryCreate({
+			scope: zodImportScope,
+			factoryName: "string",
+			replacements: ZOD_STRING_FORMAT_METHODS,
+			messageId: "preferTopLevelStringFormat",
+			ignore
+		})(context);
 	}
 });
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-zod",
-  "version": "4.9.1",
+  "version": "4.11.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.2.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",