eslint-plugin-zod 3.12.1 → 4.0.1

package/README.md

@@ -1,21 +1,21 @@
 # eslint-plugin-zod
 
-[![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.svg?style=for-the-badge&logo=npm
-[npmVersionURL]: https://www.npmjs.com/package/eslint-plugin-zod
+[npmVersionURL]: https://npmx.dev/package/eslint-plugin-zod
 [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](https://github.com/colinhacks/zod).
 
@@ -24,56 +24,42 @@ Find out more about [Oxlint's `jsPLugins`](https://oxc.rs/docs/guide/usage/linte
 
 ## Rules
 
-`zod` and `zod-mini` have distinct API surfaces.
-This plugin is primarily built for `zod`, so some rules are exclusive to `zod` and not available for `zod-mini`.
-
 <!-- begin auto-generated rules list -->
 
 💼 Configurations enabled in.\
 ✅ Set in the `recommended` configuration.\
-✔️ Set in the `recommendedMini` 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.
-
-### Universal rules (`zod` & `zod-mini`)
-
-| Name                                                                                     | Description                                                                                   | 💼    | 🔧  | 💡  | ❌  |
-| :--------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- | :---- | :-- | :-- | :-- |
-| [consistent-import](docs/rules/consistent-import.md)                                     | Enforce a consistent import style for Zod                                                     | ✅    | 🔧  |     |     |
-| [consistent-import-source](docs/rules/consistent-import-source.md)                       | Enforce consistent source from Zod imports                                                    |       |     | 💡  |     |
-| [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)             | Enforce consistent usage of Zod 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 schema variables                               | ✅ ✔️ |     |     |     |
-| [no-any-schema](docs/rules/no-any-schema.md)                                             | Disallow usage of `z.any()` in Zod 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 schemas                                                |       |     |     |     |
-| [prefer-meta](docs/rules/prefer-meta.md)                                                 | Enforce usage of `.meta()` over `.describe()`                                                 | ✅ ✔️ | 🔧  |     |     |
-| [prefer-namespace-import](docs/rules/prefer-namespace-import.md)                         | Enforce importing zod as a namespace import (`import * as z from 'zod'`)                      |       | 🔧  |     | ❌  |
-| [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 schema                                             |       |     |     | ❌  |
-| [schema-error-property-style](docs/rules/schema-error-property-style.md)                 | Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns) |       |     |     |     |
-
-### `zod` exclusive rules
-
-| Name                                                                                             | Description                                                                                                                    | 💼  | 🔧  | 💡  | ❌  |
-| :----------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- | :-- |
-| [array-style](docs/rules/array-style.md)                                                         | Enforce consistent Zod array style                                                                                             | ✅  | 🔧  |     |     |
-| [no-number-schema-with-finite](docs/rules/no-number-schema-with-finite.md)                       | Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op. | ✅  | 🔧  |     |     |
-| [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)                             | Disallow usage of `z.number().int()` as it is considered legacy                                                                | ✅  | 🔧  |     |     |
-| [no-number-schema-with-is-finite](docs/rules/no-number-schema-with-is-finite.md)                 | Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`.                                       | ✅  |     |     |     |
-| [no-number-schema-with-is-int](docs/rules/no-number-schema-with-is-int.md)                       | Disallow using deprecated `isInt` on a Zod number schema; check the `format` property instead.                                 | ✅  |     |     |     |
-| [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)                           | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |     |
-| [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)                           | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |     |
-| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md)               | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |     |
-| [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)                           | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     |     |
-| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                           | Disallow throwing errors directly inside Zod 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       |     |     |     |     |
-| [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-last](docs/rules/prefer-meta-last.md)                                               | Enforce `.meta()` as last method                                                                                               | ✅  | 🔧  |     |     |
-| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)                   | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |     |
-| [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |     |
+💡 Manually fixable by [editor suggestions](https://eslint.org/docs/latest/use/core-concepts#rule-suggestions).
+
+| Name                                                                                             | Description                                                                                                                    | 💼  | 🔧  | 💡  |
+| :----------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | :-- | :-- | :-- |
+| [array-style](docs/rules/array-style.md)                                                         | Enforce consistent Zod array style                                                                                             | ✅  | 🔧  |     |
+| [consistent-import](docs/rules/consistent-import.md)                                             | Enforce a consistent import style for Zod                                                                                      | ✅  | 🔧  |     |
+| [consistent-import-source](docs/rules/consistent-import-source.md)                               | Enforce consistent source from Zod imports                                                                                     |     |     | 💡  |
+| [consistent-object-schema-type](docs/rules/consistent-object-schema-type.md)                     | Enforce consistent usage of Zod 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 schema variables                                                                | ✅  |     |     |
+| [no-any-schema](docs/rules/no-any-schema.md)                                                     | Disallow usage of `z.any()` in Zod schemas                                                                                     | ✅  |     | 💡  |
+| [no-empty-custom-schema](docs/rules/no-empty-custom-schema.md)                                   | Disallow usage of `z.custom()` without arguments                                                                               | ✅  |     |     |
+| [no-number-schema-with-finite](docs/rules/no-number-schema-with-finite.md)                       | Disallow deprecated `z.number().finite()`. In Zod 4+ number schemas do not allow infinite values by default, so it is a no-op. | ✅  | 🔧  |     |
+| [no-number-schema-with-int](docs/rules/no-number-schema-with-int.md)                             | Disallow usage of `z.number().int()` as it is considered legacy                                                                | ✅  | 🔧  |     |
+| [no-number-schema-with-is-finite](docs/rules/no-number-schema-with-is-finite.md)                 | Disallow using deprecated `isFinite` on a Zod number schema; in v4+ it is always `true`.                                       | ✅  |     |     |
+| [no-number-schema-with-is-int](docs/rules/no-number-schema-with-is-int.md)                       | Disallow using deprecated `isInt` on a Zod number schema; check the `format` property instead.                                 | ✅  |     |     |
+| [no-number-schema-with-safe](docs/rules/no-number-schema-with-safe.md)                           | Disallow deprecated `z.number().safe()`. Use `z.int()`; `.safe()` is now identical to `.int()`.                                | ✅  | 🔧  |     |
+| [no-number-schema-with-step](docs/rules/no-number-schema-with-step.md)                           | Disallow deprecated `z.number().step()`. Use `.multipleOf()` instead.                                                          | ✅  | 🔧  |     |
+| [no-optional-and-default-together](docs/rules/no-optional-and-default-together.md)               | Disallow using both `.optional()` and `.default()` on the same Zod schema                                                      | ✅  | 🔧  |     |
+| [no-string-schema-with-uuid](docs/rules/no-string-schema-with-uuid.md)                           | Disallow usage of `z.string().uuid()` in favor of the dedicated `z.uuid()` schema                                              | ✅  | 🔧  |     |
+| [no-throw-in-refine](docs/rules/no-throw-in-refine.md)                                           | Disallow throwing errors directly inside Zod 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 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 `.meta()` over `.describe()`                                                                                  | ✅  | 🔧  |     |
+| [prefer-meta-last](docs/rules/prefer-meta-last.md)                                               | Enforce `.meta()` as last method                                                                                               | ✅  | 🔧  |     |
+| [prefer-string-schema-with-trim](docs/rules/prefer-string-schema-with-trim.md)                   | Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace                                                  | ✅  | 🔧  |     |
+| [prefer-trim-before-string-length-checks](docs/rules/prefer-trim-before-string-length-checks.md) | Enforce `.trim()` is called before string length checks to ensure accurate validation                                          | ✅  | 🔧  |     |
+| [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 schema validation (using ESQuery patterns)                                  |     |     |     |
 
 <!-- end auto-generated rules list -->
 
@@ -109,7 +95,7 @@ pnpm add --save-dev eslint eslint-plugin-zod
    eslintPluginZod.configs.recommended,
    ```
 
-Here’s a minimal example using the flat config format:
+Here's a minimal example using the flat config format:
 
 ```ts
 // eslint.config.js
@@ -159,7 +145,7 @@ pnpm add --save-dev oxlint eslint-plugin-zod
 3. Add `eslintPluginZod.configs.recommended.rules` to your Oxlint config.\
    Alternatively you can specify the rules manually
 
-Here’s a minimal example using the flat config format:
+Here's a minimal example using the flat config format:
 
 ```ts
 // oxlint.config.ts
@@ -178,9 +164,9 @@ export default defineConfig({
 
 `eslint-plugin-zod` is designed for projects that use `zod@^4`.
 While the plugin analyzes Zod schemas in your code,
-it doesn’t import or depend on Zod at runtime.
+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`.
+Zod is declared as an optional peer dependency in the plugin's `package.json`.
 
 If your project uses Zod v4, 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.
+If you're not using Zod (for example, in a separate ESLint workspace), you don't need to install it.

package/dist/index.cjs

@@ -21,12 +21,10 @@ 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_last = require("./rules/prefer-meta-last.cjs");
 const require_prefer_meta = require("./rules/prefer-meta.cjs");
-const require_prefer_namespace_import = require("./rules/prefer-namespace-import.cjs");
 const require_prefer_string_schema_with_trim = require("./rules/prefer-string-schema-with-trim.cjs");
 const require_prefer_trim_before_string_length_checks = require("./rules/prefer-trim-before-string-length-checks.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 eslintPluginZod = {
@@ -57,22 +55,17 @@ const eslintPluginZod = {
 		"prefer-enum-over-literal-union": require_prefer_enum_over_literal_union.preferEnumOverLiteralUnion,
 		"prefer-meta": require_prefer_meta.preferMeta,
 		"prefer-meta-last": require_prefer_meta_last.preferMetaLast,
-		"prefer-namespace-import": require_prefer_namespace_import.preferNamespaceImport,
 		"prefer-string-schema-with-trim": require_prefer_string_schema_with_trim.preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": require_prefer_trim_before_string_length_checks.preferTrimBeforeStringLengthChecks,
 		"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
 	}
 };
-const baseConfig = {
+const recommendedConfig = {
 	name: `${require_meta.PLUGIN_NAME}/recommended`,
 	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
-	plugins: { zod: eslintPluginZod }
-};
-const recommendedConfig = {
-	...baseConfig,
+	plugins: { zod: eslintPluginZod },
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
@@ -97,26 +90,13 @@ const recommendedConfig = {
 		"zod/require-error-message": "error"
 	}
 };
-const recommendedConfigMini = {
-	...baseConfig,
-	rules: {
-		"zod/consistent-schema-var-name": "error",
-		"zod/no-any-schema": "error",
-		"zod/prefer-meta": "error",
-		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error"
-	}
-};
 var src_default = {
 	...eslintPluginZod,
-	configs: {
-		recommended: recommendedConfig,
-		recommendedMini: recommendedConfigMini
-	}
+	configs: { recommended: recommendedConfig }
 };
 /**
 * 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.d.cts

@@ -13,7 +13,6 @@ interface CompatiblePlugin {
 declare const _default: {
   configs: {
     recommended: CompatibleConfig;
-    recommendedMini: CompatibleConfig;
   };
   meta: {
     name: string;

package/dist/index.d.mts

@@ -13,7 +13,6 @@ interface CompatiblePlugin {
 declare const _default: {
   configs: {
     recommended: CompatibleConfig;
-    recommendedMini: CompatibleConfig;
   };
   meta: {
     name: string;

package/dist/index.mjs

@@ -21,12 +21,10 @@ import { noUnknownSchema } from "./rules/no-unknown-schema.mjs";
 import { preferEnumOverLiteralUnion } from "./rules/prefer-enum-over-literal-union.mjs";
 import { preferMetaLast } from "./rules/prefer-meta-last.mjs";
 import { preferMeta } from "./rules/prefer-meta.mjs";
-import { preferNamespaceImport } from "./rules/prefer-namespace-import.mjs";
 import { preferStringSchemaWithTrim } from "./rules/prefer-string-schema-with-trim.mjs";
 import { preferTrimBeforeStringLengthChecks } from "./rules/prefer-trim-before-string-length-checks.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 eslintPluginZod = {
@@ -57,22 +55,17 @@ const eslintPluginZod = {
 		"prefer-enum-over-literal-union": preferEnumOverLiteralUnion,
 		"prefer-meta": preferMeta,
 		"prefer-meta-last": preferMetaLast,
-		"prefer-namespace-import": preferNamespaceImport,
 		"prefer-string-schema-with-trim": preferStringSchemaWithTrim,
 		"prefer-trim-before-string-length-checks": preferTrimBeforeStringLengthChecks,
 		"require-brand-type-parameter": requireBrandTypeParameter,
 		"require-error-message": requireErrorMessage,
-		"require-schema-suffix": requireSchemaSuffix,
 		"schema-error-property-style": schemaErrorPropertyStyle
 	}
 };
-const baseConfig = {
+const recommendedConfig = {
 	name: `${PLUGIN_NAME}/recommended`,
 	files: ["**/*.{js,mjs,cjs,jsx,mjsx,ts,tsx,mtsx}"],
-	plugins: { zod: eslintPluginZod }
-};
-const recommendedConfig = {
-	...baseConfig,
+	plugins: { zod: eslintPluginZod },
 	rules: {
 		"zod/array-style": "error",
 		"zod/consistent-import": "error",
@@ -97,26 +90,13 @@ const recommendedConfig = {
 		"zod/require-error-message": "error"
 	}
 };
-const recommendedConfigMini = {
-	...baseConfig,
-	rules: {
-		"zod/consistent-schema-var-name": "error",
-		"zod/no-any-schema": "error",
-		"zod/prefer-meta": "error",
-		"zod/require-brand-type-parameter": "error",
-		"zod/require-error-message": "error"
-	}
-};
 var src_default = {
 	...eslintPluginZod,
-	configs: {
-		recommended: recommendedConfig,
-		recommendedMini: recommendedConfigMini
-	}
+	configs: { recommended: recommendedConfig }
 };
 /**
 * 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,11 +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"));
-/** @see https://github.com/marcalexiei/eslint-plugin-zod/pull/97 */
-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,10 +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"));
-/** @see https://github.com/marcalexiei/eslint-plugin-zod/pull/97 */
-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/array-style.cjs

@@ -1,18 +1,16 @@
+require("../_virtual/_rolldown/runtime.cjs");
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
-const require_track_zod_schema_imports = require("../utils/track-zod-schema-imports.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
 //#region src/rules/array-style.ts
 const ZOD_ARRAY_STYLES = ["function", "method"];
 const defaultOptions = { style: "function" };
-const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("zod");
+const { trackZodSchemaImports } = (0, _eslint_zod_utils.createZodSchemaImportTrack)(_eslint_zod_utils.zodImportScope);
 const arrayStyle = require_create_plugin_rule.createZodPluginRule({
 	name: "array-style",
 	meta: {
 		type: "suggestion",
 		fixable: "code",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent Zod array style"
-		},
+		docs: { description: "Enforce consistent Zod array style" },
 		messages: {
 			useFunction: "Use z.array(schema) instead of schema.array().",
 			useMethod: "Use schema.array() instead of z.array(schema)."

package/dist/rules/array-style.mjs

@@ -1,18 +1,15 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+import { createZodSchemaImportTrack, zodImportScope } from "@eslint-zod/utils";
 //#region src/rules/array-style.ts
 const ZOD_ARRAY_STYLES = ["function", "method"];
 const defaultOptions = { style: "function" };
-const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const { trackZodSchemaImports } = createZodSchemaImportTrack(zodImportScope);
 const arrayStyle = createZodPluginRule({
 	name: "array-style",
 	meta: {
 		type: "suggestion",
 		fixable: "code",
-		docs: {
-			zodImportAllowedSource,
-			description: "Enforce consistent Zod array style"
-		},
+		docs: { description: "Enforce consistent Zod array style" },
 		messages: {
 			useFunction: "Use z.array(schema) instead of schema.array().",
 			useMethod: "Use schema.array() instead of z.array(schema)."

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

@@ -1,15 +1,13 @@
+require("../_virtual/_rolldown/runtime.cjs");
 const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
-const require_is_zod_import_source = require("../utils/is-zod-import-source.cjs");
+let _eslint_zod_utils = require("@eslint-zod/utils");
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
 	name: "consistent-import-source",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource: "all",
-			description: "Enforce consistent source from Zod imports"
-		},
+		docs: { description: "Enforce consistent source from Zod imports" },
 		messages: {
 			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
 			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
@@ -21,7 +19,7 @@ const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
 				description: "An array of allowed Zod import sources.",
 				items: {
 					type: "string",
-					enum: [...require_is_zod_import_source.ZOD_IMPORT_SOURCES]
+					enum: [..._eslint_zod_utils.zodImportScope.sources]
 				},
 				minItems: 1,
 				uniqueItems: true
@@ -33,7 +31,7 @@ const consistentImportSource = require_create_plugin_rule.createZodPluginRule({
 	create(context, [{ sources }]) {
 		return { ImportDeclaration(node) {
 			const sourceValue = node.source.value;
-			if (!sourceValue.startsWith("zod")) return;
+			if (!_eslint_zod_utils.zodImportScope.isAllowed(sourceValue)) return;
 			if (sources.includes(sourceValue)) return;
 			context.report({
 				node,

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

@@ -1,15 +1,12 @@
 import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
-import { ZOD_IMPORT_SOURCES } from "../utils/is-zod-import-source.mjs";
+import { zodImportScope } from "@eslint-zod/utils";
 //#region src/rules/consistent-import-source.ts
 const consistentImportSource = createZodPluginRule({
 	name: "consistent-import-source",
 	meta: {
 		hasSuggestions: true,
 		type: "suggestion",
-		docs: {
-			zodImportAllowedSource: "all",
-			description: "Enforce consistent source from Zod imports"
-		},
+		docs: { description: "Enforce consistent source from Zod imports" },
 		messages: {
 			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
 			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
@@ -21,7 +18,7 @@ const consistentImportSource = createZodPluginRule({
 				description: "An array of allowed Zod import sources.",
 				items: {
 					type: "string",
-					enum: [...ZOD_IMPORT_SOURCES]
+					enum: [...zodImportScope.sources]
 				},
 				minItems: 1,
 				uniqueItems: true
@@ -33,7 +30,7 @@ const consistentImportSource = createZodPluginRule({
 	create(context, [{ sources }]) {
 		return { ImportDeclaration(node) {
 			const sourceValue = node.source.value;
-			if (!sourceValue.startsWith("zod")) return;
+			if (!zodImportScope.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");
-const require_is_zod_import_source = require("../utils/is-zod-import-source.cjs");
-let _typescript_eslint_utils = require("@typescript-eslint/utils");
+let _eslint_zod_utils = require("@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 === _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.createZodPluginRule({
 	name: "consistent-import",
 	meta: {
 		type: "problem",
-		docs: {
-			zodImportAllowedSource: "all",
-			description: "Enforce a consistent import style for Zod"
-		},
+		docs: { description: "Enforce a consistent import style for Zod" },
 		fixable: "code",
 		messages: {
 			changeImportSyntax: "Use a {{syntax}} import for Zod.",
@@ -64,7 +18,7 @@ const consistentImport = require_create_plugin_rule.createZodPluginRule({
 			properties: { syntax: {
 				description: "Specifies the import syntax to use for Zod.",
 				type: "string",
-				enum: IMPORT_SYNTAXES
+				enum: _eslint_zod_utils.IMPORT_SYNTAXES
 			} },
 			additionalProperties: false
 		}]
@@ -77,8 +31,8 @@ const consistentImport = require_create_plugin_rule.createZodPluginRule({
 		return {
 			ImportDeclaration(node) {
 				const { source, importKind } = node;
-				if (!require_is_zod_import_source.isZodImportSource(source.value, "all")) return;
-				if (!importGroups[source.value]) importGroups[source.value] = {
+				if (!_eslint_zod_utils.zodImportScope.isAllowed(source.value)) return;
+				importGroups[source.value] ??= {
 					hasOnlyTypeImports: true,
 					nodes: []
 				};
@@ -98,7 +52,7 @@ const consistentImport = require_create_plugin_rule.createZodPluginRule({
 					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.createZodPluginRule({
 							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.createZodPluginRule({
 					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 },