eslint-plugin-zod-mini 1.1.0 → 1.2.0

package/README.md

@@ -31,21 +31,23 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).\
 💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
 
-| Name                                                                                     | Description                                                                                        | 💼  | 🔧  | 💡  |
-| :--------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------- | :-- | :-- | :-- |
-| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod Mini                                                     | ✅  | 🔧  |     |
-| [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod Mini imports                                                    |     |     | 💡  |
-| [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod Mini schema methods                                                |     |     | 💡  |
-| [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of z.infer or z.output for schema type inference                            |     | 🔧  |     |
-| [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                   | Enforce a consistent naming convention for Zod Mini schema variables                               | ✅  |     |     |
-| [no-any-schema](docs/rules/no-any-schema.md)                                             | Disallow usage of `z.any()` in Zod Mini schemas                                                    | ✅  |     | 💡  |
-| [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                           | Disallow usage of `z.custom()` without arguments                                                   | ✅  |     |     |
-| [no-unknown-schema](docs/rules/no-unknown-schema.md)                                     | Disallow usage of `z.unknown()` in Zod Mini schemas                                                |     |     |     |
-| [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-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `z.meta()` over `z.describe()`                                                    | ✅  | 🔧  |     |
-| [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)               | Require type parameter on `.brand()` functions                                                     | ✅  |     | 💡  |
-| [require-error-message](docs/rules/require-error-message.md)                             | Enforce that custom refinements include an error message                                           | ✅  | 🔧  |     |
-| [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod Mini schema validation (using ESQuery patterns) |     |     |     |
+| Name                                                                                     | Description                                                                                                              | 💼  | 🔧  | 💡  |
+| :--------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- |
+| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod Mini                                                                           | ✅  | 🔧  |     |
+| [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod Mini imports                                                                          |     |     | 💡  |
+| [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod Mini schema methods                                                                      |     |     | 💡  |
+| [consistent-schema-output-type-style](docs/rules/consistent-schema-output-type-style.md) | Enforce consistent use of z.infer or z.output for schema type inference                                                  |     | 🔧  |     |
+| [consistent-schema-var-name](docs/rules/consistent-schema-var-name.md)                   | Enforce a consistent naming convention for Zod Mini schema variables                                                     | ✅  |     |     |
+| [no-any-schema](docs/rules/no-any-schema.md)                                             | Disallow usage of `z.any()` in Zod Mini schemas                                                                          | ✅  |     | 💡  |
+| [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                           | Disallow usage of `z.custom()` without arguments                                                                         | ✅  |     |     |
+| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                   | Disallow throwing errors directly inside Zod Mini refine callbacks                                                       | ✅  |     |     |
+| [no-transform-in-record-key](docs/rules/no-transform-in-record-key.md)                   | Disallow transforms in z.record() key schemas, which can cause silent key mutations and data loss through key collisions |     |     |     |
+| [no-unknown-schema](docs/rules/no-unknown-schema.md)                                     | Disallow usage of `z.unknown()` in Zod Mini schemas                                                                      |     |     |     |
+| [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-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `z.meta()` over `z.describe()`                                                                          | ✅  | 🔧  |     |
+| [require-brand-type-parameter](docs/rules/require-brand-type-parameter.md)               | Require type parameter on `.brand()` functions                                                                           | ✅  |     | 💡  |
+| [require-error-message](docs/rules/require-error-message.md)                             | Enforce that custom refinements include an error message                                                                 | ✅  | 🔧  |     |
+| [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod Mini schema validation (using ESQuery patterns)                       |     |     |     |
 
 <!-- end auto-generated rules list -->
 

package/dist/index.cjs

@@ -6,6 +6,8 @@ const require_consistent_schema_output_type_style = require("./rules/consistent-
 const require_consistent_schema_var_name = require("./rules/consistent-schema-var-name.cjs");
 const require_no_any_schema = require("./rules/no-any-schema.cjs");
 const require_no_empty_custom_schema = require("./rules/no-empty-custom-schema.cjs");
+const require_no_throw_in_refine = require("./rules/no-throw-in-refine.cjs");
+const require_no_transform_in_record_key = require("./rules/no-transform-in-record-key.cjs");
 const require_no_unknown_schema = require("./rules/no-unknown-schema.cjs");
 const require_prefer_enum_over_literal_union = require("./rules/prefer-enum-over-literal-union.cjs");
 const require_prefer_meta = require("./rules/prefer-meta.cjs");
@@ -26,6 +28,8 @@ const eslintPluginZodMini = {
 		"consistent-schema-var-name": require_consistent_schema_var_name.consistentSchemaVarName,
 		"no-any-schema": require_no_any_schema.noAnySchema,
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
+		"no-throw-in-refine": require_no_throw_in_refine.noThrowInRefine,
+		"no-transform-in-record-key": require_no_transform_in_record_key.noTransformInRecordKey,
 		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
 		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
 		"prefer-meta": require_prefer_meta.preferMeta,
@@ -43,6 +47,7 @@ const recommendedConfig = {
 		"zod-mini/consistent-schema-var-name": "error",
 		"zod-mini/no-any-schema": "error",
 		"zod-mini/no-empty-custom-schema": "error",
+		"zod-mini/no-throw-in-refine": "error",
 		"zod-mini/prefer-enum-over-literal-union": "error",
 		"zod-mini/prefer-meta": "error",
 		"zod-mini/require-brand-type-parameter": "error",

package/dist/index.mjs

@@ -6,6 +6,8 @@ import { consistentSchemaOutputTypeStyle } from "./rules/consistent-schema-outpu
 import { consistentSchemaVarName } from "./rules/consistent-schema-var-name.mjs";
 import { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
+import { noThrowInRefine } from "./rules/no-throw-in-refine.mjs";
+import { noTransformInRecordKey } from "./rules/no-transform-in-record-key.mjs";
 import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
 import { preferMeta } from "./rules/prefer-meta.mjs";
@@ -26,6 +28,8 @@ const eslintPluginZodMini = {
 		"consistent-schema-var-name": consistentSchemaVarName,
 		"no-any-schema": noAnySchema,
 		"no-empty-custom-schema": noEmptyCustomSchema,
+		"no-throw-in-refine": noThrowInRefine,
+		"no-transform-in-record-key": noTransformInRecordKey,
 		"no-unknown-schema": noUnknownSchema,
 		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
 		"prefer-meta": preferMeta,
@@ -43,6 +47,7 @@ const recommendedConfig = {
 		"zod-mini/consistent-schema-var-name": "error",
 		"zod-mini/no-any-schema": "error",
 		"zod-mini/no-empty-custom-schema": "error",
+		"zod-mini/no-throw-in-refine": "error",
 		"zod-mini/prefer-enum-over-literal-union": "error",
 		"zod-mini/prefer-meta": "error",
 		"zod-mini/require-brand-type-parameter": "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/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.createZodMiniPluginRule({
 	name: "consistent-import-source",
@@ -28,31 +28,7 @@ const consistentImportSource = require_create_plugin_rule.createZodMiniPluginRul
 		}]
 	},
 	defaultOptions: [{ sources: ["zod/mini"] }],
-	create(context, [{ sources }]) {
-		return { ImportDeclaration(node) {
-			const sourceValue = node.source.value;
-			if (!_eslint_zod_utils.zodMiniImportScope.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.zodMiniImportScope)
 });
 //#endregion
 exports.consistentImportSource = consistentImportSource;

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

@@ -1,5 +1,6 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
 import { zodMiniImportScope } from "@eslint-zod/utils";
+import { buildConsistentImportSourceCreate } from "@eslint-zod/utils/rule-builders/consistent-import-source";
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = createZodMiniPluginRule({
 	name: "consistent-import-source",
@@ -27,31 +28,7 @@ const consistentImportSource = createZodMiniPluginRule({
 		}]
 	},
 	defaultOptions: [{ sources: ["zod/mini"] }],
-	create(context, [{ sources }]) {
-		return { ImportDeclaration(node) {
-			const sourceValue = node.source.value;
-			if (!zodMiniImportScope.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(zodMiniImportScope)
 });
 //#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.createZodMiniPluginRule({
 	name: "consistent-import",
@@ -18,90 +18,13 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 			properties: { syntax: {
 				description: "Specifies the import syntax to use for Zod Mini.",
 				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.zodMiniImportScope.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.zodMiniImportScope)
 });
 //#endregion
 exports.consistentImport = consistentImport;

package/dist/rules/consistent-import.mjs

@@ -1,5 +1,6 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { IMPORT_SYNTAXES, getNamespaceAliasNameFrom, isGroupFirstImportKindValidForSyntax, shouldIdentifierBeRenamed, zodMiniImportScope } from "@eslint-zod/utils";
+import { zodMiniImportScope } from "@eslint-zod/utils";
+import { IMPORT_SYNTAXES, buildConsistentImportCreate } from "@eslint-zod/utils/rule-builders/consistent-import";
 //#region src/rules/consistent-import.ts
 const consistentImport = createZodMiniPluginRule({
 	name: "consistent-import",
@@ -23,84 +24,7 @@ const consistentImport = createZodMiniPluginRule({
 		}]
 	},
 	defaultOptions: [{ syntax: "namespace" }],
-	create(context, [options]) {
-		const { syntax } = options;
-		const { sourceCode } = context;
-		const importGroups = {};
-		return {
-			ImportDeclaration(node) {
-				const { source, importKind } = node;
-				if (!zodMiniImportScope.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(zodMiniImportScope)
 });
 //#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.zodMiniImportScope);
 const consistentObjectSchemaType = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
@@ -36,44 +34,7 @@ const consistentObjectSchemaType = require_create_plugin_rule.createZodMiniPlugi
 		}]
 	},
 	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.zodMiniImportScope)
 });
 //#endregion
 exports.consistentObjectSchemaType = consistentObjectSchemaType;

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

@@ -1,6 +1,6 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodMiniImportScope } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { zodMiniImportScope } 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(zodMiniImportScope);
 const consistentObjectSchemaType = createZodMiniPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
@@ -35,44 +34,7 @@ const consistentObjectSchemaType = createZodMiniPluginRule({
 		}]
 	},
 	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(zodMiniImportScope)
 });
 //#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.zodMiniImportScope);
+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.createZodMiniPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
@@ -20,48 +16,13 @@ const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodMini
 			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.zodMiniImportScope)
 });
 //#endregion
 exports.consistentSchemaOutputTypeStyle = consistentSchemaOutputTypeStyle;

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

@@ -1,9 +1,6 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack, zodMiniImportScope } 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(zodMiniImportScope);
+import { zodMiniImportScope } from "@eslint-zod/utils";
+import { buildConsistentSchemaOutputTypeStyleCreate } from "@eslint-zod/utils/rule-builders/consistent-schema-output-type-style";
 const consistentSchemaOutputTypeStyle = createZodMiniPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
@@ -19,48 +16,13 @@ const consistentSchemaOutputTypeStyle = createZodMiniPluginRule({
 			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(zodMiniImportScope)
 });
 //#endregion
 export { consistentSchemaOutputTypeStyle };