eslint-plugin-zod 4.4.0 → 4.5.1

package/README.md

@@ -50,6 +50,7 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 | [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)                           | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |     |
 | [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)                           | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |     |
 | [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md)               | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |     |
+| [no-promise-schema](docs/rules/no-promise-schema.md)                                             | Disallow deprecated `z.promise()` schemas.                                                                                     | ✅  |     |     |     |
 | [no-schema-with-is-nullable](docs/rules/no-schema-with-is-nullable.md)                           | Disallow deprecated `.isNullable()` on a Zod schema; use `safeParse(null).success` instead.                                    | ✅  |     |     |     |
 | [no-schema-with-is-optional](docs/rules/no-schema-with-is-optional.md)                           | Disallow deprecated `.isOptional()` on a Zod schema; use `safeParse(undefined).success` instead.                               | ✅  |     |     |     |
 | [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)                           | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     | ❌  |

package/dist/index.cjs

@@ -15,6 +15,7 @@ const require_no_number_schema_with_is_int = require("./rules/no-number-schema-w
 const require_no_number_schema_with_safe = require("./rules/no-number-schema-with-safe.cjs");
 const require_no_number_schema_with_step = require("./rules/no-number-schema-with-step.cjs");
 const require_no_optional_and_default_together = require("./rules/no-optional-and-default-together.cjs");
+const require_no_promise_schema = require("./rules/no-promise-schema.cjs");
 const require_no_schema_with_is_nullable = require("./rules/no-schema-with-is-nullable.cjs");
 const require_no_schema_with_is_optional = require("./rules/no-schema-with-is-optional.cjs");
 const require_no_string_schema_with_uuid = require("./rules/no-string-schema-with-uuid.cjs");
@@ -56,6 +57,7 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": require_no_number_schema_with_step.noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": require_no_string_schema_with_uuid.noStringSchemaWithUuid,
 		"no-optional-and-default-together": require_no_optional_and_default_together.noOptionalAndDefaultTogether,
+		"no-promise-schema": require_no_promise_schema.noPromiseSchema,
 		"no-schema-with-is-nullable": require_no_schema_with_is_nullable.noSchemaWithIsNullable,
 		"no-schema-with-is-optional": require_no_schema_with_is_optional.noSchemaWithIsOptional,
 		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
@@ -93,6 +95,7 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-promise-schema": "error",
 		"zod/no-schema-with-is-nullable": "error",
 		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",

package/dist/index.mjs

@@ -15,6 +15,7 @@ import { noNumberSchemaWithIsInt } from "./rules/no-number-schema-with-is-int.mj
 import { noNumberSchemaWithSafe } from "./rules/no-number-schema-with-safe.mjs";
 import { noNumberSchemaWithStep } from "./rules/no-number-schema-with-step.mjs";
 import { noOptionalAndDefaultTogether } from "./rules/no-optional-and-default-together.mjs";
+import { noPromiseSchema } from "./rules/no-promise-schema.mjs";
 import { noSchemaWithIsNullable } from "./rules/no-schema-with-is-nullable.mjs";
 import { noSchemaWithIsOptional } from "./rules/no-schema-with-is-optional.mjs";
 import { noStringSchemaWithUuid } from "./rules/no-string-schema-with-uuid.mjs";
@@ -56,6 +57,7 @@ const eslintPluginZod = {
 		"no-number-schema-with-step": noNumberSchemaWithStep,
 		"no-string-schema-with-uuid": noStringSchemaWithUuid,
 		"no-optional-and-default-together": noOptionalAndDefaultTogether,
+		"no-promise-schema": noPromiseSchema,
 		"no-schema-with-is-nullable": noSchemaWithIsNullable,
 		"no-schema-with-is-optional": noSchemaWithIsOptional,
 		"no-throw-in-refine": noThrowInRefine,
@@ -93,6 +95,7 @@ const recommendedConfig = {
 		"zod/no-number-schema-with-step": "error",
 		"zod/no-string-schema-with-uuid": "error",
 		"zod/no-optional-and-default-together": "error",
+		"zod/no-promise-schema": "error",
 		"zod/no-schema-with-is-nullable": "error",
 		"zod/no-schema-with-is-optional": "error",
 		"zod/no-throw-in-refine": "error",

package/dist/meta.cjs

@@ -1,4 +1,3 @@
-require("./_virtual/_rolldown/runtime.cjs");
 let node_fs = require("node:fs");
 //#region src/meta.ts
 const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));

package/dist/rules/array-style.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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

package/dist/rules/consistent-import-source.cjs

@@ -1,6 +1,6 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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_consistent_import_source = require("@eslint-zod/utils/rule-builders/consistent-import-source");
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-import-source",
@@ -28,31 +28,7 @@ const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
 		}]
 	},
 	defaultOptions: [{ sources: ["zod"] }],
-	create(context, [{ sources }]) {
-		return { ImportDeclaration(node) {
-			const sourceValue = node.source.value;
-			if (!_eslint_zod_utils.zodImportScope.isAllowed(sourceValue)) return;
-			if (sources.includes(sourceValue)) return;
-			context.report({
-				node,
-				messageId: "sourceNotAllowed",
-				data: {
-					source: sourceValue,
-					sources: sources.map((s) => `"${s}"`).join(", ")
-				},
-				suggest: sources.map((it) => ({
-					messageId: "replaceSource",
-					data: {
-						valid: it,
-						invalid: sourceValue
-					},
-					fix(fixer) {
-						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
-					}
-				}))
-			});
-		} };
-	}
+	create: (0, _eslint_zod_utils_rule_builders_consistent_import_source.buildConsistentImportSourceCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.consistentImportSource = consistentImportSource;

package/dist/rules/consistent-import-source.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
 import { zodImportScope } from "@eslint-zod/utils";
+import { buildConsistentImportSourceCreate } from "@eslint-zod/utils/rule-builders/consistent-import-source";
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = createZodPluginRule({
 	name: "consistent-import-source",
@@ -27,31 +28,7 @@ const consistentImportSource = createZodPluginRule({
 		}]
 	},
 	defaultOptions: [{ sources: ["zod"] }],
-	create(context, [{ sources }]) {
-		return { ImportDeclaration(node) {
-			const sourceValue = node.source.value;
-			if (!zodImportScope.isAllowed(sourceValue)) return;
-			if (sources.includes(sourceValue)) return;
-			context.report({
-				node,
-				messageId: "sourceNotAllowed",
-				data: {
-					source: sourceValue,
-					sources: sources.map((s) => `"${s}"`).join(", ")
-				},
-				suggest: sources.map((it) => ({
-					messageId: "replaceSource",
-					data: {
-						valid: it,
-						invalid: sourceValue
-					},
-					fix(fixer) {
-						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
-					}
-				}))
-			});
-		} };
-	}
+	create: buildConsistentImportSourceCreate(zodImportScope)
 });
 //#endregion
 export { consistentImportSource };

package/dist/rules/consistent-import.cjs

@@ -1,6 +1,6 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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_consistent_import = require("@eslint-zod/utils/rule-builders/consistent-import");
 //#region src/rules/consistent-import.ts
 const consistentImport = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-import",
@@ -18,90 +18,13 @@ const consistentImport = require_create_plugin_rule.createZodPluginRule({
 			properties: { syntax: {
 				description: "Specifies the import syntax to use for Zod.",
 				type: "string",
-				enum: _eslint_zod_utils.IMPORT_SYNTAXES
+				enum: _eslint_zod_utils_rule_builders_consistent_import.IMPORT_SYNTAXES
 			} },
 			additionalProperties: false
 		}]
 	},
 	defaultOptions: [{ syntax: "namespace" }],
-	create(context, [options]) {
-		const { syntax } = options;
-		const { sourceCode } = context;
-		const importGroups = {};
-		return {
-			ImportDeclaration(node) {
-				const { source, importKind } = node;
-				if (!_eslint_zod_utils.zodImportScope.isAllowed(source.value)) return;
-				importGroups[source.value] ??= {
-					hasOnlyTypeImports: true,
-					nodes: []
-				};
-				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
-				importGroups[source.value].nodes.push(node);
-			},
-			"Program:exit": function() {
-				let namespaceAliasNameIndex = 0;
-				for (const importGroup of Object.values(importGroups)) {
-					const { hasOnlyTypeImports, nodes } = importGroup;
-					const [firstImportNode, ...othersImportNodes] = nodes;
-					/**
-					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
-					* to add the namespace prefix
-					*/
-					const nodesWithVariablesToUpdate = [];
-					let namespaceAliasName = null;
-					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
-						if (!namespaceAliasName) {
-							namespaceAliasName = (0, _eslint_zod_utils.getNamespaceAliasNameFrom)(specifier);
-							if (namespaceAliasName) continue;
-						}
-						nodesWithVariablesToUpdate.push(specifier);
-					}
-					if (!namespaceAliasName) {
-						namespaceAliasName = "z";
-						if (namespaceAliasNameIndex > 0) {
-							namespaceAliasName = `z${namespaceAliasNameIndex}`;
-							namespaceAliasNameIndex += 1;
-						}
-					}
-					if (!(0, _eslint_zod_utils.isGroupFirstImportKindValidForSyntax)(importGroup, syntax)) context.report({
-						node: firstImportNode,
-						messageId: "changeImportSyntax",
-						data: { syntax },
-						fix(fixer) {
-							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
-							let importSpecifier;
-							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
-							else importSpecifier = `{ z as ${namespaceAliasName} }`;
-							else importSpecifier = `* as ${namespaceAliasName}`;
-							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
-							return fixer.replaceText(firstImportNode, newImportText);
-						}
-					});
-					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
-					for (const ref of allReferences) {
-						const { identifier } = ref;
-						if ((0, _eslint_zod_utils.shouldIdentifierBeRenamed)(identifier)) context.report({
-							node: identifier,
-							messageId: "convertUsage",
-							data: { syntax },
-							fix(fixer) {
-								const newId = `${namespaceAliasName}.${identifier.name}`;
-								return fixer.replaceText(identifier, newId);
-							}
-						});
-					}
-					for (const extraImport of othersImportNodes) context.report({
-						node: extraImport,
-						messageId: "removeDuplicate",
-						fix(fixer) {
-							return fixer.removeRange(extraImport.range);
-						}
-					});
-				}
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_builders_consistent_import.buildConsistentImportCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.consistentImport = consistentImport;

package/dist/rules/consistent-import.mjs

@@ -1,5 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { IMPORT_SYNTAXES, getNamespaceAliasNameFrom, isGroupFirstImportKindValidForSyntax, shouldIdentifierBeRenamed, zodImportScope } from "@eslint-zod/utils";
+import { zodImportScope } from "@eslint-zod/utils";
+import { IMPORT_SYNTAXES, buildConsistentImportCreate } from "@eslint-zod/utils/rule-builders/consistent-import";
 //#region src/rules/consistent-import.ts
 const consistentImport = createZodPluginRule({
 	name: "consistent-import",
@@ -23,84 +24,7 @@ const consistentImport = createZodPluginRule({
 		}]
 	},
 	defaultOptions: [{ syntax: "namespace" }],
-	create(context, [options]) {
-		const { syntax } = options;
-		const { sourceCode } = context;
-		const importGroups = {};
-		return {
-			ImportDeclaration(node) {
-				const { source, importKind } = node;
-				if (!zodImportScope.isAllowed(source.value)) return;
-				importGroups[source.value] ??= {
-					hasOnlyTypeImports: true,
-					nodes: []
-				};
-				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
-				importGroups[source.value].nodes.push(node);
-			},
-			"Program:exit": function() {
-				let namespaceAliasNameIndex = 0;
-				for (const importGroup of Object.values(importGroups)) {
-					const { hasOnlyTypeImports, nodes } = importGroup;
-					const [firstImportNode, ...othersImportNodes] = nodes;
-					/**
-					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
-					* to add the namespace prefix
-					*/
-					const nodesWithVariablesToUpdate = [];
-					let namespaceAliasName = null;
-					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
-						if (!namespaceAliasName) {
-							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
-							if (namespaceAliasName) continue;
-						}
-						nodesWithVariablesToUpdate.push(specifier);
-					}
-					if (!namespaceAliasName) {
-						namespaceAliasName = "z";
-						if (namespaceAliasNameIndex > 0) {
-							namespaceAliasName = `z${namespaceAliasNameIndex}`;
-							namespaceAliasNameIndex += 1;
-						}
-					}
-					if (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
-						node: firstImportNode,
-						messageId: "changeImportSyntax",
-						data: { syntax },
-						fix(fixer) {
-							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
-							let importSpecifier;
-							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
-							else importSpecifier = `{ z as ${namespaceAliasName} }`;
-							else importSpecifier = `* as ${namespaceAliasName}`;
-							const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
-							return fixer.replaceText(firstImportNode, newImportText);
-						}
-					});
-					const allReferences = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it)).flatMap((it) => it.references);
-					for (const ref of allReferences) {
-						const { identifier } = ref;
-						if (shouldIdentifierBeRenamed(identifier)) context.report({
-							node: identifier,
-							messageId: "convertUsage",
-							data: { syntax },
-							fix(fixer) {
-								const newId = `${namespaceAliasName}.${identifier.name}`;
-								return fixer.replaceText(identifier, newId);
-							}
-						});
-					}
-					for (const extraImport of othersImportNodes) context.report({
-						node: extraImport,
-						messageId: "removeDuplicate",
-						fix(fixer) {
-							return fixer.removeRange(extraImport.range);
-						}
-					});
-				}
-			}
-		};
-	}
+	create: buildConsistentImportCreate(zodImportScope)
 });
 //#endregion
 export { consistentImport };

package/dist/rules/consistent-object-schema-type.cjs

@@ -1,7 +1,6 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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_consistent_object_schema_type = require("@eslint-zod/utils/rule-builders/consistent-object-schema-type");
 //#region src/rules/consistent-object-schema-type.ts
 const ZOD_OBJECT_METHODS = [
 	"object",
@@ -9,7 +8,6 @@ const ZOD_OBJECT_METHODS = [
 	"strictObject"
 ];
 const defaultOptions = { allow: ["object"] };
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const consistentObjectSchemaType = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
@@ -36,44 +34,7 @@ const consistentObjectSchemaType = require_create_plugin_rule.createZodPluginRul
 		}]
 	},
 	defaultOptions: [defaultOptions],
-	create(context, [{ allow: allowedList }]) {
-		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
-				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
-				if (allowedList.includes(schemaType)) return;
-				const { callee } = node;
-				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
-					context.report({
-						node,
-						messageId: "consistentMethod",
-						data: {
-							actual: schemaType,
-							allowedList: allowedList.join(",")
-						}
-					});
-					return;
-				}
-				if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) context.report({
-					node,
-					messageId: "consistentMethod",
-					data: {
-						actual: schemaType,
-						allowedList: allowedList.join(",")
-					},
-					suggest: allowedList.map((it) => ({
-						messageId: "useMethod",
-						data: { expected: it },
-						fix(fixer) {
-							return fixer.replaceText(callee.property, it);
-						}
-					}))
-				});
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_builders_consistent_object_schema_type.buildConsistentObjectSchemaTypeCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.consistentObjectSchemaType = consistentObjectSchemaType;

package/dist/rules/consistent-object-schema-type.mjs

@@ -1,6 +1,6 @@
 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 { buildConsistentObjectSchemaTypeCreate } from "@eslint-zod/utils/rule-builders/consistent-object-schema-type";
 //#region src/rules/consistent-object-schema-type.ts
 const ZOD_OBJECT_METHODS = [
 	"object",
@@ -8,7 +8,6 @@ const ZOD_OBJECT_METHODS = [
 	"strictObject"
 ];
 const defaultOptions = { allow: ["object"] };
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const consistentObjectSchemaType = createZodPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
@@ -35,44 +34,7 @@ const consistentObjectSchemaType = createZodPluginRule({
 		}]
 	},
 	defaultOptions: [defaultOptions],
-	create(context, [{ allow: allowedList }]) {
-		const { importDeclarationListener, detectZodSchemaRootNode } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			CallExpression(node) {
-				const schemaType = detectZodSchemaRootNode(node)?.schemaType;
-				if (!schemaType || !ZOD_OBJECT_METHODS.includes(schemaType)) return;
-				if (allowedList.includes(schemaType)) return;
-				const { callee } = node;
-				if (callee.type === AST_NODE_TYPES.Identifier) {
-					context.report({
-						node,
-						messageId: "consistentMethod",
-						data: {
-							actual: schemaType,
-							allowedList: allowedList.join(",")
-						}
-					});
-					return;
-				}
-				if (callee.type === AST_NODE_TYPES.MemberExpression) context.report({
-					node,
-					messageId: "consistentMethod",
-					data: {
-						actual: schemaType,
-						allowedList: allowedList.join(",")
-					},
-					suggest: allowedList.map((it) => ({
-						messageId: "useMethod",
-						data: { expected: it },
-						fix(fixer) {
-							return fixer.replaceText(callee.property, it);
-						}
-					}))
-				});
-			}
-		};
-	}
+	create: buildConsistentObjectSchemaTypeCreate(zodImportScope)
 });
 //#endregion
 export { consistentObjectSchemaType };

package/dist/rules/consistent-schema-output-type-style.cjs

@@ -1,10 +1,6 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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/consistent-schema-output-type-style.ts
-const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
+let _eslint_zod_utils_rule_builders_consistent_schema_output_type_style = require("@eslint-zod/utils/rule-builders/consistent-schema-output-type-style");
 const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
@@ -20,48 +16,13 @@ const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodPlug
 			properties: { style: {
 				description: "Decides which style to use for schema type inference",
 				type: "string",
-				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+				enum: [...["infer", "output"]]
 			} },
 			additionalProperties: false
 		}]
 	},
 	defaultOptions: [{ style: "output" }],
-	create(context, [{ style }]) {
-		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			TSTypeReference(node) {
-				const { typeName } = node;
-				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.TSQualifiedName) {
-					const { left, right } = typeName;
-					if (left.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
-					const usedStyle = right.name;
-					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
-					context.report({
-						node: right,
-						messageId: style === "infer" ? "useInfer" : "useOutput",
-						fix(fixer) {
-							return fixer.replaceText(right, style);
-						}
-					});
-					return;
-				}
-				if (typeName.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
-					const originalName = getNamedImportOriginal(typeName.name);
-					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
-					const targetLocalName = getNamedImportLocal(style);
-					context.report({
-						node: typeName,
-						messageId: style === "infer" ? "useInfer" : "useOutput",
-						fix(fixer) {
-							if (!targetLocalName || targetLocalName === "infer") return null;
-							return fixer.replaceText(typeName, targetLocalName);
-						}
-					});
-				}
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_builders_consistent_schema_output_type_style.buildConsistentSchemaOutputTypeStyleCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.consistentSchemaOutputTypeStyle = consistentSchemaOutputTypeStyle;

package/dist/rules/consistent-schema-output-type-style.mjs

@@ -1,9 +1,6 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-//#region src/rules/consistent-schema-output-type-style.ts
-const ZOD_SCHEMA_TYPE_STYLES = ["infer", "output"];
-const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
+import { zodImportScope } from "@eslint-zod/utils";
+import { buildConsistentSchemaOutputTypeStyleCreate } from "@eslint-zod/utils/rule-builders/consistent-schema-output-type-style";
 const consistentSchemaOutputTypeStyle = createZodPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
@@ -19,48 +16,13 @@ const consistentSchemaOutputTypeStyle = createZodPluginRule({
 			properties: { style: {
 				description: "Decides which style to use for schema type inference",
 				type: "string",
-				enum: [...ZOD_SCHEMA_TYPE_STYLES]
+				enum: [...["infer", "output"]]
 			} },
 			additionalProperties: false
 		}]
 	},
 	defaultOptions: [{ style: "output" }],
-	create(context, [{ style }]) {
-		const { importDeclarationListener, isZodNamespace, getNamedImportOriginal, getNamedImportLocal } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			TSTypeReference(node) {
-				const { typeName } = node;
-				if (typeName.type === AST_NODE_TYPES.TSQualifiedName) {
-					const { left, right } = typeName;
-					if (left.type !== AST_NODE_TYPES.Identifier || !isZodNamespace(left.name)) return;
-					const usedStyle = right.name;
-					if (usedStyle !== "infer" && usedStyle !== "output" || usedStyle === style) return;
-					context.report({
-						node: right,
-						messageId: style === "infer" ? "useInfer" : "useOutput",
-						fix(fixer) {
-							return fixer.replaceText(right, style);
-						}
-					});
-					return;
-				}
-				if (typeName.type === AST_NODE_TYPES.Identifier) {
-					const originalName = getNamedImportOriginal(typeName.name);
-					if (originalName !== "infer" && originalName !== "output" || originalName === style) return;
-					const targetLocalName = getNamedImportLocal(style);
-					context.report({
-						node: typeName,
-						messageId: style === "infer" ? "useInfer" : "useOutput",
-						fix(fixer) {
-							if (!targetLocalName || targetLocalName === "infer") return null;
-							return fixer.replaceText(typeName, targetLocalName);
-						}
-					});
-				}
-			}
-		};
-	}
+	create: buildConsistentSchemaOutputTypeStyleCreate(zodImportScope)
 });
 //#endregion
 export { consistentSchemaOutputTypeStyle };

package/dist/rules/consistent-schema-var-name.cjs

@@ -1,9 +1,7 @@
-require("../_virtual/_rolldown/runtime.cjs");
 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_consistent_schema_var_name = require("@eslint-zod/utils/rule-builders/consistent-schema-var-name");
 //#region src/rules/consistent-schema-var-name.ts
-const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const consistentSchemaVarName = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-schema-var-name",
 	meta: {
@@ -26,29 +24,7 @@ const consistentSchemaVarName = require_create_plugin_rule.createZodPluginRule({
 		}]
 	},
 	defaultOptions: [{ after: "Schema" }],
-	create(context, [{ before = "", after = "" }]) {
-		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
-		return {
-			ImportDeclaration: importDeclarationListener,
-			VariableDeclarator(node) {
-				const initNode = node.init;
-				if (initNode?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
-				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
-				if (_eslint_zod_utils.ZOD_NON_SCHEMA_PRODUCING_METHODS.some((it) => chainMethods.includes(it))) return;
-				if (node.id.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return;
-				const { name } = node.id;
-				const validPrefix = !before || name.startsWith(before);
-				const validSuffix = !after || name.endsWith(after);
-				if (validPrefix && validSuffix) return;
-				const expected = (validPrefix ? "" : before) + name + (validSuffix ? "" : after);
-				context.report({
-					node,
-					messageId: "invalidName",
-					data: { expected }
-				});
-			}
-		};
-	}
+	create: (0, _eslint_zod_utils_rule_builders_consistent_schema_var_name.buildConsistentSchemaVarNameCreate)(_eslint_zod_utils.zodImportScope)
 });
 //#endregion
 exports.consistentSchemaVarName = consistentSchemaVarName;