eslint-plugin-zod 4.10.0 → 4.12.0

package/README.md

@@ -63,6 +63,7 @@ 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()`                                                      | ✅  | 🔧  |     |     |

package/dist/index.cjs

@@ -28,6 +28,7 @@ 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");
@@ -76,6 +77,7 @@ 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,

package/dist/index.mjs

@@ -28,6 +28,7 @@ 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";
@@ -76,6 +77,7 @@ 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,

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-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-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.10.0",
+  "version": "4.12.0",
   "description": "ESLint plugin that adds custom linting rules to enforce best practices when using Zod",
   "keywords": [
     "eslint",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "@typescript-eslint/utils": "^8.67.0",
-    "@eslint-zod/utils": "3.1.0"
+    "@eslint-zod/utils": "3.3.0"
   },
   "devDependencies": {
     "@typescript-eslint/rule-tester": "8.67.0",