eslint-plugin-zod-mini 0.1.0

package/dist/rules/require-error-message.cjs

@@ -0,0 +1,85 @@
+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/require-error-message.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const requireErrorMessage = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "require-error-message",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce that custom refinements include an error message"
+		},
+		messages: {
+			requireErrorMessage: "Custom refinements must include an error message",
+			preferError: "Use the \"error\" property instead of the deprecated \"message\" property",
+			removeMessage: "The \"message\" property is deprecated; use \"error\""
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const refines = collectZodChainMethods(node).filter((it) => it.name === "refine" || it.name === "custom");
+				if (refines.length === 0) return;
+				for (const refine of refines) {
+					const refineNode = refine.node;
+					if (refineNode.arguments.length < 2) {
+						context.report({
+							messageId: "requireErrorMessage",
+							node: refineNode
+						});
+						continue;
+					}
+					const [, params] = refineNode.arguments;
+					if (params.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) continue;
+					if (params.type !== _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) continue;
+					let errorPropertyNode;
+					let messagePropertyNode;
+					for (const property of params.properties) if (property.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && property.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+						if (property.key.name === "error") errorPropertyNode = property;
+						if (property.key.name === "message") messagePropertyNode = property;
+						if (errorPropertyNode && messagePropertyNode) break;
+					}
+					if (errorPropertyNode && messagePropertyNode) {
+						context.report({
+							messageId: "removeMessage",
+							node: messagePropertyNode,
+							fix(fixer) {
+								const { sourceCode } = context;
+								const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+								let [, end] = messagePropertyNode.range;
+								if (nextToken?.value === ",") end = nextToken.range[1];
+								return fixer.removeRange([messagePropertyNode.range[0], end]);
+							}
+						});
+						continue;
+					}
+					if (messagePropertyNode && !errorPropertyNode) {
+						context.report({
+							messageId: "preferError",
+							node: params,
+							fix(fixer) {
+								return fixer.replaceTextRange(messagePropertyNode.key.range, "error");
+							}
+						});
+						continue;
+					}
+					if (!errorPropertyNode) context.report({
+						messageId: "requireErrorMessage",
+						node: params
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+exports.requireErrorMessage = requireErrorMessage;

package/dist/rules/require-error-message.mjs

@@ -0,0 +1,84 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/require-error-message.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const requireErrorMessage = createZodMiniPluginRule({
+	name: "require-error-message",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce that custom refinements include an error message"
+		},
+		messages: {
+			requireErrorMessage: "Custom refinements must include an error message",
+			preferError: "Use the \"error\" property instead of the deprecated \"message\" property",
+			removeMessage: "The \"message\" property is deprecated; use \"error\""
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const refines = collectZodChainMethods(node).filter((it) => it.name === "refine" || it.name === "custom");
+				if (refines.length === 0) return;
+				for (const refine of refines) {
+					const refineNode = refine.node;
+					if (refineNode.arguments.length < 2) {
+						context.report({
+							messageId: "requireErrorMessage",
+							node: refineNode
+						});
+						continue;
+					}
+					const [, params] = refineNode.arguments;
+					if (params.type === AST_NODE_TYPES.Literal) continue;
+					if (params.type !== AST_NODE_TYPES.ObjectExpression) continue;
+					let errorPropertyNode;
+					let messagePropertyNode;
+					for (const property of params.properties) if (property.type === AST_NODE_TYPES.Property && property.key.type === AST_NODE_TYPES.Identifier) {
+						if (property.key.name === "error") errorPropertyNode = property;
+						if (property.key.name === "message") messagePropertyNode = property;
+						if (errorPropertyNode && messagePropertyNode) break;
+					}
+					if (errorPropertyNode && messagePropertyNode) {
+						context.report({
+							messageId: "removeMessage",
+							node: messagePropertyNode,
+							fix(fixer) {
+								const { sourceCode } = context;
+								const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+								let [, end] = messagePropertyNode.range;
+								if (nextToken?.value === ",") end = nextToken.range[1];
+								return fixer.removeRange([messagePropertyNode.range[0], end]);
+							}
+						});
+						continue;
+					}
+					if (messagePropertyNode && !errorPropertyNode) {
+						context.report({
+							messageId: "preferError",
+							node: params,
+							fix(fixer) {
+								return fixer.replaceTextRange(messagePropertyNode.key.range, "error");
+							}
+						});
+						continue;
+					}
+					if (!errorPropertyNode) context.report({
+						messageId: "requireErrorMessage",
+						node: params
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { requireErrorMessage };

package/dist/rules/require-schema-suffix.cjs

@@ -0,0 +1,69 @@
+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/require-schema-suffix.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const requireSchemaSuffix = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "require-schema-suffix",
+	meta: {
+		type: "suggestion",
+		deprecated: { message: "Use `zod-mini/consistent-schema-var-name`" },
+		docs: {
+			zodImportAllowedSource,
+			description: "Require schema suffix when declaring a Zod Mini schema"
+		},
+		messages: { noSchemaSuffix: "Use the \"{{suffix}}\" suffix for Zod Mini schemas. Rename this to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: { suffix: {
+				type: "string",
+				description: "The required suffix for Zod Mini schema variables"
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ suffix: "Schema" }],
+	create(context, [{ suffix }]) {
+		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 ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || node.id.name.endsWith(suffix)) return;
+				context.report({
+					node,
+					messageId: "noSchemaSuffix",
+					data: {
+						suffix,
+						expected: `${node.id.name}${suffix}`
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.requireSchemaSuffix = requireSchemaSuffix;

package/dist/rules/require-schema-suffix.mjs

@@ -0,0 +1,68 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/require-schema-suffix.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const requireSchemaSuffix = createZodMiniPluginRule({
+	name: "require-schema-suffix",
+	meta: {
+		type: "suggestion",
+		deprecated: { message: "Use `zod-mini/consistent-schema-var-name`" },
+		docs: {
+			zodImportAllowedSource,
+			description: "Require schema suffix when declaring a Zod Mini schema"
+		},
+		messages: { noSchemaSuffix: "Use the \"{{suffix}}\" suffix for Zod Mini schemas. Rename this to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: { suffix: {
+				type: "string",
+				description: "The required suffix for Zod Mini schema variables"
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ suffix: "Schema" }],
+	create(context, [{ suffix }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== AST_NODE_TYPES.Identifier || node.id.name.endsWith(suffix)) return;
+				context.report({
+					node,
+					messageId: "noSchemaSuffix",
+					data: {
+						suffix,
+						expected: `${node.id.name}${suffix}`
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { requireSchemaSuffix };

package/dist/rules/schema-error-property-style.cjs

@@ -0,0 +1,96 @@
+const require_runtime = 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 esquery = require("esquery");
+esquery = require_runtime.__toESM(esquery, 1);
+//#region src/rules/schema-error-property-style.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const schemaErrorPropertyStyle = require_create_plugin_rule.createZodMiniPluginRule({
+	name: "schema-error-property-style",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent style for error messages in Zod Mini schema validation (using ESQuery patterns)"
+		},
+		messages: {
+			invalidSelector: "Invalid ESQuery selector: \"{{selector}}\"",
+			invalidStyle: "Error message must follow the pattern \"{{selector}}\" (e.g., {{example}}). Found: {{actual}}."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				selector: {
+					description: "An ESQuery string to match the required pattern",
+					type: "string"
+				},
+				example: {
+					description: "Example code to help the user understand the required pattern",
+					type: "string"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		selector: "Literal,TemplateLiteral",
+		example: "'error message'"
+	}],
+	create(context, [{ selector, example }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		/**
+		* Parsing `selector` to ensure it is valid,
+		* if not report an error and return empty rule listener
+		*/
+		try {
+			esquery.default.parse(selector);
+		} catch {
+			context.report({
+				loc: {
+					line: 1,
+					column: 0
+				},
+				messageId: "invalidSelector",
+				data: { selector }
+			});
+			return {};
+		}
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType !== "custom" && !collectZodChainMethods(node).some((it) => it.name === "refine")) return;
+				if (node.arguments.length < 2) return;
+				let errorMessageNode;
+				const [, params] = node.arguments;
+				switch (params.type) {
+					case _typescript_eslint_utils.AST_NODE_TYPES.Literal:
+					case _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral:
+						errorMessageNode = params;
+						break;
+					case _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression:
+						for (const property of params.properties) if (property.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && property.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && property.key.name === "error") {
+							errorMessageNode = property.value;
+							break;
+						}
+						break;
+				}
+				if (!errorMessageNode) return;
+				if (esquery.default.matches(errorMessageNode, esquery.default.parse(selector), errorMessageNode)) return;
+				context.report({
+					node,
+					messageId: "invalidStyle",
+					data: {
+						selector,
+						example,
+						actual: context.sourceCode.getText(errorMessageNode)
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+exports.schemaErrorPropertyStyle = schemaErrorPropertyStyle;

package/dist/rules/schema-error-property-style.mjs

@@ -0,0 +1,94 @@
+import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import esquery from "esquery";
+//#region src/rules/schema-error-property-style.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const schemaErrorPropertyStyle = createZodMiniPluginRule({
+	name: "schema-error-property-style",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce consistent style for error messages in Zod Mini schema validation (using ESQuery patterns)"
+		},
+		messages: {
+			invalidSelector: "Invalid ESQuery selector: \"{{selector}}\"",
+			invalidStyle: "Error message must follow the pattern \"{{selector}}\" (e.g., {{example}}). Found: {{actual}}."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				selector: {
+					description: "An ESQuery string to match the required pattern",
+					type: "string"
+				},
+				example: {
+					description: "Example code to help the user understand the required pattern",
+					type: "string"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		selector: "Literal,TemplateLiteral",
+		example: "'error message'"
+	}],
+	create(context, [{ selector, example }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		/**
+		* Parsing `selector` to ensure it is valid,
+		* if not report an error and return empty rule listener
+		*/
+		try {
+			esquery.parse(selector);
+		} catch {
+			context.report({
+				loc: {
+					line: 1,
+					column: 0
+				},
+				messageId: "invalidSelector",
+				data: { selector }
+			});
+			return {};
+		}
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType !== "custom" && !collectZodChainMethods(node).some((it) => it.name === "refine")) return;
+				if (node.arguments.length < 2) return;
+				let errorMessageNode;
+				const [, params] = node.arguments;
+				switch (params.type) {
+					case AST_NODE_TYPES.Literal:
+					case AST_NODE_TYPES.TemplateLiteral:
+						errorMessageNode = params;
+						break;
+					case AST_NODE_TYPES.ObjectExpression:
+						for (const property of params.properties) if (property.type === AST_NODE_TYPES.Property && property.key.type === AST_NODE_TYPES.Identifier && property.key.name === "error") {
+							errorMessageNode = property.value;
+							break;
+						}
+						break;
+				}
+				if (!errorMessageNode) return;
+				if (esquery.matches(errorMessageNode, esquery.parse(selector), errorMessageNode)) return;
+				context.report({
+					node,
+					messageId: "invalidStyle",
+					data: {
+						selector,
+						example,
+						actual: context.sourceCode.getText(errorMessageNode)
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { schemaErrorPropertyStyle };

package/dist/src/index.d.ts

@@ -0,0 +1,21 @@
+interface CompatibleConfig {
+    name?: string;
+    rules?: object;
+    plugins?: Record<string, CompatiblePlugin>;
+}
+interface CompatiblePlugin {
+    meta: {
+        name: string;
+        version: string;
+    };
+}
+declare const _default: {
+    configs: {
+        recommended: CompatibleConfig;
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+};
+export default _default;

package/dist/src/index.js

@@ -0,0 +1,56 @@
+import { PLUGIN_NAME, PLUGIN_VERSION } from './meta.js';
+import { consistentImportSource } from './rules/consistent-import-source.js';
+import { consistentImport } from './rules/consistent-import.js';
+import { consistentObjectSchemaType } from './rules/consistent-object-schema-type.js';
+import { consistentSchemaOutputTypeStyle } from './rules/consistent-schema-output-type-style.js';
+import { consistentSchemaVarName } from './rules/consistent-schema-var-name.js';
+import { noAnySchema } from './rules/no-any-schema.js';
+import { noEmptyCustomSchema } from './rules/no-empty-custom-schema.js';
+import { noUnknownSchema } from './rules/no-unknown-schema.js';
+import { preferMeta } from './rules/prefer-meta.js';
+import { preferNamespaceImport } from './rules/prefer-namespace-import.js';
+import { requireBrandTypeParameter } from './rules/require-brand-type-parameter.js';
+import { requireErrorMessage } from './rules/require-error-message.js';
+import { requireSchemaSuffix } from './rules/require-schema-suffix.js';
+import { schemaErrorPropertyStyle } from './rules/schema-error-property-style.js';
+const eslintPluginZodMini = {
+    meta: {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+    },
+    rules: {
+        'consistent-import': consistentImport,
+        'consistent-import-source': consistentImportSource,
+        'consistent-object-schema-type': consistentObjectSchemaType,
+        'consistent-schema-output-type-style': consistentSchemaOutputTypeStyle,
+        'consistent-schema-var-name': consistentSchemaVarName,
+        'no-any-schema': noAnySchema,
+        'no-empty-custom-schema': noEmptyCustomSchema,
+        'no-unknown-schema': noUnknownSchema,
+        'prefer-meta': preferMeta,
+        'prefer-namespace-import': preferNamespaceImport,
+        'require-brand-type-parameter': requireBrandTypeParameter,
+        'require-error-message': requireErrorMessage,
+        'require-schema-suffix': requireSchemaSuffix,
+        'schema-error-property-style': schemaErrorPropertyStyle,
+    },
+};
+const baseConfig = {
+    name: `${PLUGIN_NAME}/recommended`,
+    files: ['**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}'],
+    plugins: {
+        'zod-mini': eslintPluginZodMini,
+    },
+};
+const recommendedConfig = Object.assign(Object.assign({}, baseConfig), { rules: {
+        'zod-mini/consistent-import': 'error',
+        'zod-mini/consistent-schema-var-name': 'error',
+        'zod-mini/no-any-schema': 'error',
+        'zod-mini/no-empty-custom-schema': 'error',
+        'zod-mini/prefer-meta': 'error',
+        'zod-mini/require-brand-type-parameter': 'error',
+        'zod-mini/require-error-message': 'error',
+    } });
+export default Object.assign(Object.assign({}, eslintPluginZodMini), { configs: {
+        recommended: recommendedConfig,
+    } });

package/dist/src/meta.d.ts

@@ -0,0 +1,3 @@
+declare const PLUGIN_NAME: string, PLUGIN_VERSION: string;
+export { PLUGIN_NAME, PLUGIN_VERSION };
+export declare function getRuleURL(ruleID: string): string;

package/dist/src/meta.js

@@ -0,0 +1,8 @@
+import { readFileSync } from 'node:fs';
+const packageJSON = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = packageJSON;
+export { PLUGIN_NAME, PLUGIN_VERSION };
+const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, '');
+export function getRuleURL(ruleID) {
+    return `${PLUGIN_HOMEPAGE}/blob/v${PLUGIN_VERSION}/docs/rules/${ruleID}.md`;
+}

package/dist/src/rules/consistent-import-source.d.ts

@@ -0,0 +1,11 @@
+import type { ZodImportSource } from '@eslint-zod/utils';
+import type { TSESLint } from '@typescript-eslint/utils';
+type MessageIds = 'sourceNotAllowed' | 'replaceSource';
+export declare const consistentImportSource: TSESLint.RuleModule<MessageIds, [{
+    sources: Array<ZodImportSource>;
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
+    name: string;
+};
+export {};

package/dist/src/rules/consistent-import-source.js

@@ -0,0 +1,64 @@
+import { ZOD_IMPORT_SOURCES } from '@eslint-zod/utils';
+import { createZodMiniPluginRule } from '../utils/create-plugin-rule.js';
+export const consistentImportSource = createZodMiniPluginRule({
+    name: 'consistent-import-source',
+    meta: {
+        hasSuggestions: true,
+        type: 'suggestion',
+        docs: {
+            zodImportAllowedSource: 'zod-mini',
+            description: 'Enforce consistent source from Zod Mini imports',
+        },
+        messages: {
+            sourceNotAllowed: '"{{source}}" is not allowed. Available values are: {{sources}}',
+            replaceSource: 'Replace "{{invalid}}" with "{{valid}}"',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    sources: {
+                        type: 'array',
+                        description: 'An array of allowed Zod import sources.',
+                        items: {
+                            type: 'string',
+                            enum: [...ZOD_IMPORT_SOURCES],
+                        },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ sources: ['zod/mini'] }],
+    create(context, [{ sources }]) {
+        return {
+            ImportDeclaration(node) {
+                const sourceValue = node.source.value;
+                if (!sourceValue.startsWith('zod')) {
+                    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));
+                        },
+                    })),
+                });
+            },
+        };
+    },
+});

package/dist/src/rules/consistent-import-source.spec.d.ts

@@ -0,0 +1 @@
+export {};