eslint-plugin-zod 4.9.0 → 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/array-style.cjs

@@ -1,9 +1,5 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
-//#region src/rules/array-style.ts
-const ZOD_ARRAY_STYLES = ["function", "method"];
-const defaultOptions = { style: "function" };
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 	name: "array-style",
 	meta: {
@@ -19,67 +15,62 @@ const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 			properties: { style: {
 				description: "Decides which style for zod array function",
 				type: "string",
-				enum: ZOD_ARRAY_STYLES
+				enum: ["function", "method"]
 			} },
 			additionalProperties: false
 		}]
 	},
-	defaultOptions: [defaultOptions],
+	defaultOptions: [{ style: "function" }],
 	create(context, [{ style }]) {
 		const { sourceCode } = context;
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (!zodSchemaMeta) return;
-				const { schemaDecl, schemaType } = zodSchemaMeta;
-				if (style === "method") {
-					if (schemaType === "array") {
-						if (schemaDecl === "namespace") {
-							context.report({
-								node,
-								messageId: "useMethod",
-								fix(fixer) {
-									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
-									if (!arrayCall) return null;
-									const arg = arrayCall.node.arguments.at(0);
-									if (!arg) return null;
-									const argText = sourceCode.getText(arg);
-									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
-								}
-							});
-							return;
-						}
-						context.report({
-							node,
-							messageId: "useMethod"
-						});
-					}
-					return;
-				}
-				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
-				if (arrayMethod) {
-					const arrayNode = arrayMethod.node;
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		return createSchemaVisitor({ onSchema(node, zodSchemaMeta) {
+			const { schemaDecl, schemaType } = zodSchemaMeta;
+			if (style === "method") {
+				if (schemaType === "array") {
 					if (schemaDecl === "namespace") {
 						context.report({
 							node,
-							messageId: "useFunction",
+							messageId: "useMethod",
 							fix(fixer) {
-								const callee = arrayNode.callee;
-								const objText = sourceCode.getText(callee.object);
-								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+								const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+								if (!arrayCall) return null;
+								const arg = arrayCall.node.arguments.at(0);
+								if (!arg) return null;
+								const argText = sourceCode.getText(arg);
+								return fixer.replaceText(arrayCall.node, `${argText}.array()`);
 							}
 						});
 						return;
 					}
 					context.report({
 						node,
-						messageId: "useFunction"
+						messageId: "useMethod"
 					});
 				}
+				return;
+			}
+			const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+			if (arrayMethod) {
+				const arrayNode = arrayMethod.node;
+				if (schemaDecl === "namespace") {
+					context.report({
+						node,
+						messageId: "useFunction",
+						fix(fixer) {
+							const callee = arrayNode.callee;
+							const objText = sourceCode.getText(callee.object);
+							return fixer.replaceText(arrayNode, `z.array(${objText})`);
+						}
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useFunction"
+				});
 			}
-		};
+		} });
 	}
 });
 //#endregion

package/dist/rules/array-style.mjs

@@ -1,9 +1,5 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
-//#region src/rules/array-style.ts
-const ZOD_ARRAY_STYLES = ["function", "method"];
-const defaultOptions = { style: "function" };
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+import { zodImportScope } from "@eslint-zod/utils";
 const arrayStyle = createZodPluginRule({
 	name: "array-style",
 	meta: {
@@ -19,67 +15,62 @@ const arrayStyle = createZodPluginRule({
 			properties: { style: {
 				description: "Decides which style for zod array function",
 				type: "string",
-				enum: ZOD_ARRAY_STYLES
+				enum: ["function", "method"]
 			} },
 			additionalProperties: false
 		}]
 	},
-	defaultOptions: [defaultOptions],
+	defaultOptions: [{ style: "function" }],
 	create(context, [{ style }]) {
 		const { sourceCode } = context;
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (!zodSchemaMeta) return;
-				const { schemaDecl, schemaType } = zodSchemaMeta;
-				if (style === "method") {
-					if (schemaType === "array") {
-						if (schemaDecl === "namespace") {
-							context.report({
-								node,
-								messageId: "useMethod",
-								fix(fixer) {
-									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
-									if (!arrayCall) return null;
-									const arg = arrayCall.node.arguments.at(0);
-									if (!arg) return null;
-									const argText = sourceCode.getText(arg);
-									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
-								}
-							});
-							return;
-						}
-						context.report({
-							node,
-							messageId: "useMethod"
-						});
-					}
-					return;
-				}
-				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
-				if (arrayMethod) {
-					const arrayNode = arrayMethod.node;
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		return createSchemaVisitor({ onSchema(node, zodSchemaMeta) {
+			const { schemaDecl, schemaType } = zodSchemaMeta;
+			if (style === "method") {
+				if (schemaType === "array") {
 					if (schemaDecl === "namespace") {
 						context.report({
 							node,
-							messageId: "useFunction",
+							messageId: "useMethod",
 							fix(fixer) {
-								const callee = arrayNode.callee;
-								const objText = sourceCode.getText(callee.object);
-								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+								const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+								if (!arrayCall) return null;
+								const arg = arrayCall.node.arguments.at(0);
+								if (!arg) return null;
+								const argText = sourceCode.getText(arg);
+								return fixer.replaceText(arrayCall.node, `${argText}.array()`);
 							}
 						});
 						return;
 					}
 					context.report({
 						node,
-						messageId: "useFunction"
+						messageId: "useMethod"
 					});
 				}
+				return;
+			}
+			const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+			if (arrayMethod) {
+				const arrayNode = arrayMethod.node;
+				if (schemaDecl === "namespace") {
+					context.report({
+						node,
+						messageId: "useFunction",
+						fix(fixer) {
+							const callee = arrayNode.callee;
+							const objText = sourceCode.getText(callee.object);
+							return fixer.replaceText(arrayNode, `z.array(${objText})`);
+						}
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "useFunction"
+				});
 			}
-		};
+		} });
 	}
 });
 //#endregion

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

@@ -1,8 +1,7 @@
 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 { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
 	name: "no-native-enum",
 	meta: {
@@ -13,25 +12,7 @@ const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (zodSchemaMeta?.schemaType !== "nativeEnum") return;
-				const [{ node: rootMethodNode }] = collectZodChainMethods(zodSchemaMeta.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,8 +1,7 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildNoNativeEnumCreate } from "@eslint-zod/utils/rule-builders/no-native-enum";
 //#region src/rules/no-native-enum.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNativeEnum = createZodPluginRule({
 	name: "no-native-enum",
 	meta: {
@@ -13,25 +12,7 @@ const noNativeEnum = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (zodSchemaMeta?.schemaType !== "nativeEnum") return;
-				const [{ node: rootMethodNode }] = collectZodChainMethods(zodSchemaMeta.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-finite.cjs

@@ -1,7 +1,6 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
 //#region src/rules/no-number-schema-with-finite.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const noNumberSchemaWithFinite = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-finite",
 	meta: {
@@ -13,18 +12,18 @@ const noNumberSchemaWithFinite = require_create_plugin_rule.createZodPluginRule(
 	},
 	defaultOptions: [],
 	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+		const { createSchemaVisitor, collectZodChainMethods } = _eslint_zod_utils.zodImportScope.createTracker();
+		return createSchemaVisitor({
+			schemaType: "number",
+			onSchema(node, zodSchemaMeta) {
+				if (!(0, _eslint_zod_utils.getZodChainedMethodNames)(zodSchemaMeta).includes("finite")) return;
 				const methods = collectZodChainMethods(node);
-				const finiteIndex = methods.findIndex((m) => m.name === "finite" && m.node === node);
-				if (finiteIndex === -1) return;
+				const finiteIndex = methods.findIndex((m, index) => index > 0 && m.name === "finite");
 				context.report({
 					node,
 					messageId: "removeFinite",
 					fix(fixer) {
+						if (finiteIndex === -1) return null;
 						return (0, _eslint_zod_utils.buildZodChainRemoveMethodFix)({
 							fixer,
 							methods,
@@ -33,7 +32,7 @@ const noNumberSchemaWithFinite = require_create_plugin_rule.createZodPluginRule(
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

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

@@ -1,7 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { buildZodChainRemoveMethodFix, createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+import { buildZodChainRemoveMethodFix, getZodChainedMethodNames, zodImportScope } from "@eslint-zod/utils";
 //#region src/rules/no-number-schema-with-finite.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNumberSchemaWithFinite = createZodPluginRule({
 	name: "no-number-schema-with-finite",
 	meta: {
@@ -13,18 +12,18 @@ const noNumberSchemaWithFinite = createZodPluginRule({
 	},
 	defaultOptions: [],
 	create(context) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				if (detectZodSchemaRootNode(node)?.schemaType !== "number") return;
+		const { createSchemaVisitor, collectZodChainMethods } = zodImportScope.createTracker();
+		return createSchemaVisitor({
+			schemaType: "number",
+			onSchema(node, zodSchemaMeta) {
+				if (!getZodChainedMethodNames(zodSchemaMeta).includes("finite")) return;
 				const methods = collectZodChainMethods(node);
-				const finiteIndex = methods.findIndex((m) => m.name === "finite" && m.node === node);
-				if (finiteIndex === -1) return;
+				const finiteIndex = methods.findIndex((m, index) => index > 0 && m.name === "finite");
 				context.report({
 					node,
 					messageId: "removeFinite",
 					fix(fixer) {
+						if (finiteIndex === -1) return null;
 						return buildZodChainRemoveMethodFix({
 							fixer,
 							methods,
@@ -33,7 +32,7 @@ const noNumberSchemaWithFinite = createZodPluginRule({
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

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

@@ -1,7 +1,6 @@
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
 //#region src/rules/no-number-schema-with-int.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-int",
 	meta: {
@@ -14,12 +13,10 @@ const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 	defaultOptions: [],
 	create(context) {
 		const { sourceCode } = context;
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (zodSchemaMeta?.schemaType !== "number") return;
+		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;
@@ -40,7 +37,7 @@ const noNumberSchemaWithInt = require_create_plugin_rule.createZodPluginRule({
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

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

@@ -1,7 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { buildZodChainReplacementFix, createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
+import { buildZodChainReplacementFix, zodImportScope } from "@eslint-zod/utils";
 //#region src/rules/no-number-schema-with-int.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNumberSchemaWithInt = createZodPluginRule({
 	name: "no-number-schema-with-int",
 	meta: {
@@ -14,12 +13,10 @@ const noNumberSchemaWithInt = createZodPluginRule({
 	defaultOptions: [],
 	create(context) {
 		const { sourceCode } = context;
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const zodSchemaMeta = detectZodSchemaRootNode(node);
-				if (zodSchemaMeta?.schemaType !== "number") return;
+		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;
@@ -40,7 +37,7 @@ const noNumberSchemaWithInt = createZodPluginRule({
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

package/dist/rules/no-number-schema-with-is-finite.cjs

@@ -1,8 +1,7 @@
 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_patterns_deprecated_schema_property = require("@eslint-zod/utils/rule-patterns/deprecated-schema-property");
 //#region src/rules/no-number-schema-with-is-finite.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const noNumberSchemaWithIsFinite = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-is-finite",
 	meta: {
@@ -12,23 +11,12 @@ const noNumberSchemaWithIsFinite = require_create_plugin_rule.createZodPluginRul
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			MemberExpression(node) {
-				if (node.computed) return;
-				if (node.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
-				if (node.property.name !== "isFinite") return;
-				if (node.object.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
-				if (!isZodNumberSchemaCallExpression(node.object)) return;
-				context.report({
-					node,
-					messageId: "deprecated"
-				});
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_patterns_deprecated_schema_property.buildDeprecatedSchemaPropertyCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		schemaType: "number",
+		propertyName: "isFinite",
+		messageId: "deprecated"
+	})
 });
 //#endregion
 exports.noNumberSchemaWithIsFinite = noNumberSchemaWithIsFinite;

package/dist/rules/no-number-schema-with-is-finite.mjs

@@ -1,8 +1,7 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildDeprecatedSchemaPropertyCreate } from "@eslint-zod/utils/rule-patterns/deprecated-schema-property";
 //#region src/rules/no-number-schema-with-is-finite.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNumberSchemaWithIsFinite = createZodPluginRule({
 	name: "no-number-schema-with-is-finite",
 	meta: {
@@ -12,23 +11,12 @@ const noNumberSchemaWithIsFinite = createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			MemberExpression(node) {
-				if (node.computed) return;
-				if (node.property.type !== AST_NODE_TYPES.Identifier) return;
-				if (node.property.name !== "isFinite") return;
-				if (node.object.type !== AST_NODE_TYPES.CallExpression) return;
-				if (!isZodNumberSchemaCallExpression(node.object)) return;
-				context.report({
-					node,
-					messageId: "deprecated"
-				});
-			}
-		};
-	}
+	create: buildDeprecatedSchemaPropertyCreate({
+		scope: zodImportScope,
+		schemaType: "number",
+		propertyName: "isFinite",
+		messageId: "deprecated"
+	})
 });
 //#endregion
 export { noNumberSchemaWithIsFinite };

package/dist/rules/no-number-schema-with-is-int.cjs

@@ -1,8 +1,7 @@
 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_patterns_deprecated_schema_property = require("@eslint-zod/utils/rule-patterns/deprecated-schema-property");
 //#region src/rules/no-number-schema-with-is-int.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const noNumberSchemaWithIsInt = require_create_plugin_rule.createZodPluginRule({
 	name: "no-number-schema-with-is-int",
 	meta: {
@@ -12,23 +11,12 @@ const noNumberSchemaWithIsInt = require_create_plugin_rule.createZodPluginRule({
 		schema: []
 	},
 	defaultOptions: [],
-	create(context) {
-		const { importDeclarationListener, isZodNumberSchemaCallExpression } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			MemberExpression(node) {
-				if (node.computed) return;
-				if (node.property.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
-				if (node.property.name !== "isInt") return;
-				if (node.object.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return;
-				if (!isZodNumberSchemaCallExpression(node.object)) return;
-				context.report({
-					node,
-					messageId: "useFormat"
-				});
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_patterns_deprecated_schema_property.buildDeprecatedSchemaPropertyCreate)({
+		scope: _eslint_zod_utils.zodImportScope,
+		schemaType: "number",
+		propertyName: "isInt",
+		messageId: "useFormat"
+	})
 });
 //#endregion
 exports.noNumberSchemaWithIsInt = noNumberSchemaWithIsInt;