eslint-plugin-zod 4.9.0 → 4.9.1

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

@@ -2,7 +2,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");
 //#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: {
@@ -14,23 +13,21 @@ const noNativeEnum = require_create_plugin_rule.createZodPluginRule({
 	},
 	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);
+		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;
+						if (rootMethodNode?.callee.type !== _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) return null;
 						return fixer.replaceText(rootMethodNode.callee.property, "enum");
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

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 { zodImportScope } from "@eslint-zod/utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 //#region src/rules/no-native-enum.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNativeEnum = createZodPluginRule({
 	name: "no-native-enum",
 	meta: {
@@ -14,23 +13,21 @@ const noNativeEnum = createZodPluginRule({
 	},
 	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);
+		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;
+						if (rootMethodNode?.callee.type !== AST_NODE_TYPES.MemberExpression) return null;
 						return fixer.replaceText(rootMethodNode.callee.property, "enum");
 					}
 				});
 			}
-		};
+		});
 	}
 });
 //#endregion

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;

package/dist/rules/no-number-schema-with-is-int.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-int.ts
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const noNumberSchemaWithIsInt = createZodPluginRule({
 	name: "no-number-schema-with-is-int",
 	meta: {
@@ -12,23 +11,12 @@ const noNumberSchemaWithIsInt = 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 !== "isInt") return;
-				if (node.object.type !== AST_NODE_TYPES.CallExpression) return;
-				if (!isZodNumberSchemaCallExpression(node.object)) return;
-				context.report({
-					node,
-					messageId: "useFormat"
-				});
-			}
-		};
-	}
+	create: buildDeprecatedSchemaPropertyCreate({
+		scope: zodImportScope,
+		schemaType: "number",
+		propertyName: "isInt",
+		messageId: "useFormat"
+	})
 });
 //#endregion
 export { noNumberSchemaWithIsInt };