eslint-plugin-zod-mini 0.1.0 → 1.0.1

package/README.md

@@ -1,21 +1,21 @@
 # eslint-plugin-zod-mini
 
-[![CI][CIBadge]][CIURL]
+[![CI Status][CIBadge]][CIURL]
 [![Code style: prettier][CodeStyleBadge]][CodeStyleURL]
 [![Lint: eslint][lintBadge]][lintURL]
-[![npm version][npmVersionBadge]][npmVersionURL]
-[![issues][issuesBadge]][issuesURL]
+[![Open on npmx][npmVersionBadge]][npmVersionURL]
+[![Open issue tracker][issuesBadge]][issuesURL]
 
-[CIBadge]: https://img.shields.io/github/actions/workflow/status/marcalexiei/eslint-plugin-zod/ci.yml?style=for-the-badge&logo=github&event=push&label=CI
-[CIURL]: https://github.com/marcalexiei/eslint-plugin-zod/actions/workflows/CI.yml/badge.svg
+[CIBadge]: https://img.shields.io/github/actions/workflow/status/marcalexiei/eslint-zod/ci.yml?style=for-the-badge&logo=github&event=push&label=CI
+[CIURL]: https://github.com/marcalexiei/eslint-zod/actions/workflows/CI.yml/badge.svg
 [CodeStyleBadge]: https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=for-the-badge&logo=prettier
 [CodeStyleURL]: https://prettier.io
 [npmVersionBadge]: https://img.shields.io/npm/v/eslint-plugin-zod-mini.svg?style=for-the-badge&logo=npm
-[npmVersionURL]: https://www.npmjs.com/package/eslint-plugin-zod-mini
+[npmVersionURL]: https://npmx.dev/package/eslint-plugin-zod-mini
 [lintBadge]: https://img.shields.io/badge/lint-eslint-3A33D1?logo=eslint&style=for-the-badge
 [lintURL]: https://eslint.org
-[issuesBadge]: https://img.shields.io/github/issues/marcalexiei/eslint-plugin-zod.svg?style=for-the-badge
-[issuesURL]: https://github.com/marcalexiei/eslint-plugin-zod/issues
+[issuesBadge]: https://img.shields.io/github/issues/marcalexiei/eslint-zod.svg?style=for-the-badge
+[issuesURL]: https://github.com/marcalexiei/eslint-zod/issues
 
 [ESLint](https://eslint.org) plugin that adds custom linting rules to enforce best practices when using [Zod Mini](https://zod.dev/?id=zod-mini) (`zod/mini`).
 
@@ -29,25 +29,22 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 💼 Configurations enabled in.\
 ✅ Set in the `recommended` configuration.\
 🔧 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).\
-❌ Deprecated.
-
-| 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-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `z.meta()` over `z.describe()`                                                    | ✅  | 🔧  |     |     |
-| [prefer-namespace-import](docs/rules/prefer-namespace-import.md)                         | Enforce importing zod/mini as a namespace import (`import * as z from 'zod/mini'`)                 |     | 🔧  |     | ❌  |
-| [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                                           | ✅  | 🔧  |     |     |
-| [require-schema-suffix](docs/rules/require-schema-suffix.md)                             | Require schema suffix when declaring a Zod Mini schema                                             |     |     |     | ❌  |
-| [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) |     |     |     |     |
+💡 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-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 -->
 
@@ -147,3 +144,14 @@ export default defineConfig({
   },
 });
 ```
+
+## Zod peer dependency version
+
+`eslint-plugin-zod-mini` is designed for projects that use `zod@^4` (specifically `zod/mini`).
+While the plugin analyzes Zod Mini schemas in your code,
+it doesn't import or depend on Zod at runtime.
+To document this relationship without forcing installation,
+Zod is declared as an optional peer dependency in the plugin's `package.json`.
+
+If your project uses Zod Mini, the plugin will automatically lint your schemas.
+If you're not using Zod (for example, in a separate ESLint workspace), you don't need to install it.

package/dist/index.cjs

@@ -8,10 +8,8 @@ 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_unknown_schema = require("./rules/no-unknown-schema.cjs");
 const require_prefer_meta = require("./rules/prefer-meta.cjs");
-const require_prefer_namespace_import = require("./rules/prefer-namespace-import.cjs");
 const require_require_brand_type_parameter = require("./rules/require-brand-type-parameter.cjs");
 const require_require_error_message = require("./rules/require-error-message.cjs");
-const require_require_schema_suffix = require("./rules/require-schema-suffix.cjs");
 const require_schema_error_property_style = require("./rules/schema-error-property-style.cjs");
 //#region src/index.ts
 const eslintPluginZodMini = {
@@ -29,10 +27,8 @@ const eslintPluginZodMini = {
 		"no-empty-custom-schema": require_no_empty_custom_schema.noEmptyCustomSchema,
 		"no-unknown-schema": require_no_unknown_schema.noUnknownSchema,
 		"prefer-meta": require_prefer_meta.preferMeta,
-		"prefer-namespace-import": require_prefer_namespace_import.preferNamespaceImport,
 		"require-brand-type-parameter": require_require_brand_type_parameter.requireBrandTypeParameter,
 		"require-error-message": require_require_error_message.requireErrorMessage,
-		"require-schema-suffix": require_require_schema_suffix.requireSchemaSuffix,
 		"schema-error-property-style": require_schema_error_property_style.schemaErrorPropertyStyle
 	}
 };
@@ -56,7 +52,7 @@ var src_default = {
 };
 /**
 * why `satisfies`?
-* @see https://github.com/marcalexiei/eslint-plugin-zod/issues/49
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
 */
 //#endregion
 module.exports = src_default;

package/dist/index.mjs

@@ -8,10 +8,8 @@ import { noAnySchema } from "./rules/no-any-schema.mjs";
 import { noEmptyCustomSchema } from "./rules/no-empty-custom-schema.mjs";
 import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
 import { preferMeta } from "./rules/prefer-meta.mjs";
-import { preferNamespaceImport } from "./rules/prefer-namespace-import.mjs";
 import { requireBrandTypeParameter } from "./rules/require-brand-type-parameter.mjs";
 import { requireErrorMessage } from "./rules/require-error-message.mjs";
-import { requireSchemaSuffix } from "./rules/require-schema-suffix.mjs";
 import { schemaErrorPropertyStyle } from "./rules/schema-error-property-style.mjs";
 //#region src/index.ts
 const eslintPluginZodMini = {
@@ -29,10 +27,8 @@ const eslintPluginZodMini = {
 		"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
 	}
 };
@@ -56,7 +52,7 @@ var src_default = {
 };
 /**
 * why `satisfies`?
-* @see https://github.com/marcalexiei/eslint-plugin-zod/issues/49
+* @see https://github.com/marcalexiei/eslint-zod/issues/49
 */
 //#endregion
 export { src_default as default };

package/dist/meta.cjs

@@ -1,10 +1,9 @@
 require("./_virtual/_rolldown/runtime.cjs");
 let node_fs = require("node:fs");
 //#region src/meta.ts
-const { name: PLUGIN_NAME, version: PLUGIN_VERSION, homepage } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
-const PLUGIN_HOMEPAGE = homepage.replace(/#[^#]*$/, "");
+const { name: PLUGIN_NAME, version: PLUGIN_VERSION, repository } = JSON.parse((0, node_fs.readFileSync)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
 function getRuleURL(ruleID) {
-	return `${PLUGIN_HOMEPAGE}/blob/v${PLUGIN_VERSION}/docs/rules/${ruleID}.md`;
+	return `${repository.url}/blob/HEAD/${repository.directory}/docs/rules/${ruleID}.md`;
 }
 //#endregion
 exports.PLUGIN_NAME = PLUGIN_NAME;

package/dist/meta.mjs

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

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

@@ -7,10 +7,7 @@ const consistentImportSource = require_create_plugin_rule.createZodMiniPluginRul
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource: "zod-mini",
-			description: "Enforce consistent source from Zod Mini imports"
-		},
+		docs: { description: "Enforce consistent source from Zod Mini imports" },
 		messages: {
 			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
 			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
@@ -22,7 +19,7 @@ const consistentImportSource = require_create_plugin_rule.createZodMiniPluginRul
 				description: "An array of allowed Zod import sources.",
 				items: {
 					type: "string",
-					enum: [..._eslint_zod_utils.ZOD_IMPORT_SOURCES]
+					enum: [..._eslint_zod_utils.zodMiniImportScope.sources]
 				},
 				minItems: 1,
 				uniqueItems: true
@@ -34,7 +31,7 @@ const consistentImportSource = require_create_plugin_rule.createZodMiniPluginRul
 	create(context, [{ sources }]) {
 		return { ImportDeclaration(node) {
 			const sourceValue = node.source.value;
-			if (!sourceValue.startsWith("zod")) return;
+			if (!_eslint_zod_utils.zodMiniImportScope.isAllowed(sourceValue)) return;
 			if (sources.includes(sourceValue)) return;
 			context.report({
 				node,

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

@@ -1,15 +1,12 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { ZOD_IMPORT_SOURCES } from "@eslint-zod/utils";
+import { zodMiniImportScope } from "@eslint-zod/utils";
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = createZodMiniPluginRule({
 	name: "consistent-import-source",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource: "zod-mini",
-			description: "Enforce consistent source from Zod Mini imports"
-		},
+		docs: { description: "Enforce consistent source from Zod Mini imports" },
 		messages: {
 			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
 			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
@@ -21,7 +18,7 @@ const consistentImportSource = createZodMiniPluginRule({
 				description: "An array of allowed Zod import sources.",
 				items: {
 					type: "string",
-					enum: [...ZOD_IMPORT_SOURCES]
+					enum: [...zodMiniImportScope.sources]
 				},
 				minItems: 1,
 				uniqueItems: true
@@ -33,7 +30,7 @@ const consistentImportSource = createZodMiniPluginRule({
 	create(context, [{ sources }]) {
 		return { ImportDeclaration(node) {
 			const sourceValue = node.source.value;
-			if (!sourceValue.startsWith("zod")) return;
+			if (!zodMiniImportScope.isAllowed(sourceValue)) return;
 			if (sources.includes(sourceValue)) return;
 			context.report({
 				node,

package/dist/rules/consistent-import.cjs

@@ -1,58 +1,12 @@
 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-import.ts
-const IMPORT_SYNTAXES = ["namespace", "named"];
-/**
-* Determines whether the first import in a group is valid for a given import
-* syntax (`named` or `namespace`), taking into account whether the group
-* contains only type imports.
-*
-* Rules enforced:
-* - For `named` syntax:
-*   - The first import must have exactly one specifier
-*   - That specifier must be a named import of identifier `z`
-* - For `namespace` syntax:
-*   - The first import must have exactly one namespace specifier
-* - If the group contains only type imports, the first import must explicitly
-*   be declared as `import type`
-*
-* @param group - Metadata describing the import group
-* @param syntax - Expected import syntax for the group
-* @returns `true` if the first import matches the expected syntax and type rules
-*/
-function isGroupFirstImportKindValidForSyntax(group, syntax) {
-	const { hasOnlyTypeImports, nodes } = group;
-	const [firstImportNode] = nodes;
-	const { specifiers, importKind } = firstImportNode;
-	if (specifiers.length !== 1) return false;
-	const [specifier] = specifiers;
-	if (!(syntax === "named" ? specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && specifier.imported.name === "z" : specifier.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier)) return false;
-	if (hasOnlyTypeImports) return importKind === "type";
-	return true;
-}
-function shouldIdentifierBeRenamed(node) {
-	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier) return false;
-	if (node.parent.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && node.parent.object.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.parent.object.name !== node.name) return false;
-	return true;
-}
-/**
-* From a given specifiers retrieve the most significant to use when creating an alias import
-*/
-function getNamespaceAliasNameFrom(node) {
-	if (node.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
-	if (node.imported.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
-	return null;
-}
 const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "consistent-import",
 	meta: {
 		type: "problem",
-		docs: {
-			zodImportAllowedSource: "zod-mini",
-			description: "Enforce a consistent import style for Zod Mini"
-		},
+		docs: { description: "Enforce a consistent import style for Zod Mini" },
 		fixable: "code",
 		messages: {
 			changeImportSyntax: "Use a {{syntax}} import for Zod Mini.",
@@ -64,7 +18,7 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 			properties: { syntax: {
 				description: "Specifies the import syntax to use for Zod Mini.",
 				type: "string",
-				enum: IMPORT_SYNTAXES
+				enum: _eslint_zod_utils.IMPORT_SYNTAXES
 			} },
 			additionalProperties: false
 		}]
@@ -77,8 +31,8 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 		return {
 			ImportDeclaration(node) {
 				const { source, importKind } = node;
-				if (!(0, _eslint_zod_utils.isZodImportSource)(source.value, "zod-mini")) return;
-				if (!importGroups[source.value]) importGroups[source.value] = {
+				if (!_eslint_zod_utils.zodMiniImportScope.isAllowed(source.value)) return;
+				importGroups[source.value] ??= {
 					hasOnlyTypeImports: true,
 					nodes: []
 				};
@@ -98,7 +52,7 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 					let namespaceAliasName = null;
 					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
 						if (!namespaceAliasName) {
-							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+							namespaceAliasName = (0, _eslint_zod_utils.getNamespaceAliasNameFrom)(specifier);
 							if (namespaceAliasName) continue;
 						}
 						nodesWithVariablesToUpdate.push(specifier);
@@ -110,7 +64,7 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 							namespaceAliasNameIndex += 1;
 						}
 					}
-					if (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
+					if (!(0, _eslint_zod_utils.isGroupFirstImportKindValidForSyntax)(importGroup, syntax)) context.report({
 						node: firstImportNode,
 						messageId: "changeImportSyntax",
 						data: { syntax },
@@ -127,7 +81,7 @@ const consistentImport = require_create_plugin_rule.createZodMiniPluginRule({
 					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({
+						if ((0, _eslint_zod_utils.shouldIdentifierBeRenamed)(identifier)) context.report({
 							node: identifier,
 							messageId: "convertUsage",
 							data: { syntax },

package/dist/rules/consistent-import.mjs

@@ -1,57 +1,11 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { isZodImportSource } from "@eslint-zod/utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { IMPORT_SYNTAXES, getNamespaceAliasNameFrom, isGroupFirstImportKindValidForSyntax, shouldIdentifierBeRenamed, zodMiniImportScope } from "@eslint-zod/utils";
 //#region src/rules/consistent-import.ts
-const IMPORT_SYNTAXES = ["namespace", "named"];
-/**
-* Determines whether the first import in a group is valid for a given import
-* syntax (`named` or `namespace`), taking into account whether the group
-* contains only type imports.
-*
-* Rules enforced:
-* - For `named` syntax:
-*   - The first import must have exactly one specifier
-*   - That specifier must be a named import of identifier `z`
-* - For `namespace` syntax:
-*   - The first import must have exactly one namespace specifier
-* - If the group contains only type imports, the first import must explicitly
-*   be declared as `import type`
-*
-* @param group - Metadata describing the import group
-* @param syntax - Expected import syntax for the group
-* @returns `true` if the first import matches the expected syntax and type rules
-*/
-function isGroupFirstImportKindValidForSyntax(group, syntax) {
-	const { hasOnlyTypeImports, nodes } = group;
-	const [firstImportNode] = nodes;
-	const { specifiers, importKind } = firstImportNode;
-	if (specifiers.length !== 1) return false;
-	const [specifier] = specifiers;
-	if (!(syntax === "named" ? specifier.type === AST_NODE_TYPES.ImportSpecifier && specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === "z" : specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)) return false;
-	if (hasOnlyTypeImports) return importKind === "type";
-	return true;
-}
-function shouldIdentifierBeRenamed(node) {
-	if (node.parent.type === AST_NODE_TYPES.ImportSpecifier) return false;
-	if (node.parent.type === AST_NODE_TYPES.MemberExpression && node.parent.object.type === AST_NODE_TYPES.Identifier && node.parent.object.name !== node.name) return false;
-	return true;
-}
-/**
-* From a given specifiers retrieve the most significant to use when creating an alias import
-*/
-function getNamespaceAliasNameFrom(node) {
-	if (node.type === AST_NODE_TYPES.ImportDefaultSpecifier || node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) return node.local.name;
-	if (node.imported.type === AST_NODE_TYPES.Identifier && node.imported.name === "z") return node.local.name;
-	return null;
-}
 const consistentImport = createZodMiniPluginRule({
 	name: "consistent-import",
 	meta: {
 		type: "problem",
-		docs: {
-			zodImportAllowedSource: "zod-mini",
-			description: "Enforce a consistent import style for Zod Mini"
-		},
+		docs: { description: "Enforce a consistent import style for Zod Mini" },
 		fixable: "code",
 		messages: {
 			changeImportSyntax: "Use a {{syntax}} import for Zod Mini.",
@@ -76,8 +30,8 @@ const consistentImport = createZodMiniPluginRule({
 		return {
 			ImportDeclaration(node) {
 				const { source, importKind } = node;
-				if (!isZodImportSource(source.value, "zod-mini")) return;
-				if (!importGroups[source.value]) importGroups[source.value] = {
+				if (!zodMiniImportScope.isAllowed(source.value)) return;
+				importGroups[source.value] ??= {
 					hasOnlyTypeImports: true,
 					nodes: []
 				};

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

@@ -9,16 +9,13 @@ const ZOD_OBJECT_METHODS = [
 	"strictObject"
 ];
 const defaultOptions = { allow: ["object"] };
-const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodMiniImportScope);
 const consistentObjectSchemaType = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent usage of Zod Mini schema methods"
-		},
+		docs: { description: "Enforce consistent usage of Zod Mini schema methods" },
 		messages: {
 			consistentMethod: "Inconsistent Zod Mini object schema method '{{actual}}'. Allowed: {{allowedList}}.",
 			useMethod: "Replace with '{{expected}}'."

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

@@ -1,5 +1,5 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { createZodSchemaImportTrack, zodMiniImportScope } from "@eslint-zod/utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 //#region src/rules/consistent-object-schema-type.ts
 const ZOD_OBJECT_METHODS = [
@@ -8,16 +8,13 @@ const ZOD_OBJECT_METHODS = [
 	"strictObject"
 ];
 const defaultOptions = { allow: ["object"] };
-const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodMiniImportScope);
 const consistentObjectSchemaType = createZodMiniPluginRule({
 	name: "consistent-object-schema-type",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent usage of Zod Mini schema methods"
-		},
+		docs: { description: "Enforce consistent usage of Zod Mini schema methods" },
 		messages: {
 			consistentMethod: "Inconsistent Zod Mini object schema method '{{actual}}'. Allowed: {{allowedList}}.",
 			useMethod: "Replace with '{{expected}}'."

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

@@ -4,16 +4,13 @@ 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 { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodMiniImportScope);
 const consistentSchemaOutputTypeStyle = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
 		type: "suggestion",
 		fixable: "code",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent use of z.infer or z.output for schema type inference"
-		},
+		docs: { description: "Enforce consistent use of z.infer or z.output for schema type inference" },
 		messages: {
 			useInfer: "Use infer instead of output.",
 			useOutput: "Use output instead of infer."

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

@@ -1,18 +1,15 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+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 { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodMiniImportScope);
 const consistentSchemaOutputTypeStyle = createZodMiniPluginRule({
 	name: "consistent-schema-output-type-style",
 	meta: {
 		type: "suggestion",
 		fixable: "code",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent use of z.infer or z.output for schema type inference"
-		},
+		docs: { description: "Enforce consistent use of z.infer or z.output for schema type inference" },
 		messages: {
 			useInfer: "Use infer instead of output.",
 			useOutput: "Use output instead of infer."

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

@@ -3,15 +3,12 @@ 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-var-name.ts
-const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodMiniImportScope);
 const consistentSchemaVarName = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "consistent-schema-var-name",
 	meta: {
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce a consistent naming convention for Zod Mini schema variables"
-		},
+		docs: { description: "Enforce a consistent naming convention for Zod Mini schema variables" },
 		messages: { invalidName: "Rename this Zod Mini schema to \"{{expected}}\"" },
 		schema: [{
 			type: "object",
@@ -37,26 +34,7 @@ const consistentSchemaVarName = require_create_plugin_rule.createZodMiniPluginRu
 				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 (_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);

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

@@ -1,16 +1,13 @@
 import { createZodMiniPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack } from "@eslint-zod/utils";
+import { ZOD_NON_SCHEMA_PRODUCING_METHODS, createZodSchemaImportTrack, zodMiniImportScope } from "@eslint-zod/utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 //#region src/rules/consistent-schema-var-name.ts
-const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod-mini");
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodMiniImportScope);
 const consistentSchemaVarName = createZodMiniPluginRule({
 	name: "consistent-schema-var-name",
 	meta: {
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce a consistent naming convention for Zod Mini schema variables"
-		},
+		docs: { description: "Enforce a consistent naming convention for Zod Mini schema variables" },
 		messages: { invalidName: "Rename this Zod Mini schema to \"{{expected}}\"" },
 		schema: [{
 			type: "object",
@@ -36,26 +33,7 @@ const consistentSchemaVarName = createZodMiniPluginRule({
 				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 (ZOD_NON_SCHEMA_PRODUCING_METHODS.some((it) => chainMethods.includes(it))) return;
 				if (node.id.type !== AST_NODE_TYPES.Identifier) return;
 				const { name } = node.id;
 				const validPrefix = !before || name.startsWith(before);

package/dist/rules/no-any-schema.cjs

@@ -3,16 +3,13 @@ const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
 let _eslint_zod_utils = require("@eslint-zod/utils");
 let _typescript_eslint_utils = require("@typescript-eslint/utils");
 //#region src/rules/no-any-schema.ts
-const { zodImportAllowedSource, trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)("zod-mini");
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodMiniImportScope);
 const noAnySchema = require_create_plugin_rule.createZodMiniPluginRule({
 	name: "no-any-schema",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource,
-			description: "Disallow usage of `z.any()` in Zod Mini schemas"
-		},
+		docs: { description: "Disallow usage of `z.any()` in Zod Mini schemas" },
 		messages: {
 			noZAny: "Using `z.any()` is not allowed. Please use a more specific schema.",
 			useUnknown: "Replace `z.any()` with `z.unknown()`"