eslint-plugin-zod 3.2.0 → 3.4.0

package/dist/rules/prefer-meta.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferMeta: ESLintUtils.RuleModule<"preferMeta", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferMeta: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"preferMeta", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-meta.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferMeta: ESLintUtils.RuleModule<"preferMeta", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferMeta: import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferMeta", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-meta.js

@@ -1,12 +1,13 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const preferMeta = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const preferMeta = createZodPluginRule({
     name: 'prefer-meta',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce usage of `.meta()` over `.describe()`',
         },
         messages: {

package/dist/rules/prefer-namespace-import.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferNamespaceImport = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const is_zod_import_source_js_1 = require("../utils/is-zod-import-source.cjs");
 function isGroupFirstImportTypeNamespace(group) {
     const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
@@ -42,7 +42,7 @@ function getNamespaceAliasNameFrom(node) {
     }
     return null;
 }
-exports.preferNamespaceImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+exports.preferNamespaceImport = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'prefer-namespace-import',
     meta: {
         type: 'suggestion',
@@ -50,6 +50,7 @@ exports.preferNamespaceImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
             message: "Use `zod/consistent-import` with `{ syntax: 'namespace' }`",
         },
         docs: {
+            zodImportAllowedSource: 'all',
             description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
         },
         fixable: 'code',
@@ -67,7 +68,7 @@ exports.preferNamespaceImport = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRul
         return {
             ImportDeclaration(node) {
                 const { source, importKind } = node;
-                if (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value)) {
+                if (!(0, is_zod_import_source_js_1.isZodImportSource)(source.value, 'all')) {
                     return;
                 }
                 if (!importGroups[source.value]) {

package/dist/rules/prefer-namespace-import.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferNamespaceImport: ESLintUtils.RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferNamespaceImport: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-namespace-import.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const preferNamespaceImport: ESLintUtils.RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], unknown, ESLintUtils.RuleListener> & {
+export declare const preferNamespaceImport: import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeDuplicate" | "convertUsage" | "useNamespace", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/prefer-namespace-import.js

@@ -1,5 +1,5 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
 import { isZodImportSource } from "../utils/is-zod-import-source.js";
 function isGroupFirstImportTypeNamespace(group) {
     const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
@@ -39,7 +39,7 @@ function getNamespaceAliasNameFrom(node) {
     }
     return null;
 }
-export const preferNamespaceImport = ESLintUtils.RuleCreator(getRuleURL)({
+export const preferNamespaceImport = createZodPluginRule({
     name: 'prefer-namespace-import',
     meta: {
         type: 'suggestion',
@@ -47,6 +47,7 @@ export const preferNamespaceImport = ESLintUtils.RuleCreator(getRuleURL)({
             message: "Use `zod/consistent-import` with `{ syntax: 'namespace' }`",
         },
         docs: {
+            zodImportAllowedSource: 'all',
             description: "Enforce importing zod as a namespace import (`import * as z from 'zod'`)",
         },
         fixable: 'code',
@@ -64,7 +65,7 @@ export const preferNamespaceImport = ESLintUtils.RuleCreator(getRuleURL)({
         return {
             ImportDeclaration(node) {
                 const { source, importKind } = node;
-                if (!isZodImportSource(source.value)) {
+                if (!isZodImportSource(source.value, 'all')) {
                     return;
                 }
                 if (!importGroups[source.value]) {

package/dist/rules/prefer-string-schema-with-trim.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferStringSchemaWithTrim = void 0;
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
+const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('zod');
+exports.preferStringSchemaWithTrim = (0, create_plugin_rule_js_1.createZodPluginRule)({
+    name: 'prefer-string-schema-with-trim',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace',
+        },
+        messages: {
+            addTrim: '`z.string()` schemas should use `.trim()`.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) !== 'string') {
+                    return;
+                }
+                const methods = collectZodChainMethods(zodSchemaMeta.node);
+                if (methods.some((it) => it.name === 'trim')) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'addTrim',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'addTrim',
+                    fix(fixer) {
+                        const lastMethod = methods.at(0);
+                        return fixer.insertTextAfter(lastMethod.node, '.trim()');
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/prefer-string-schema-with-trim.d.cts

@@ -0,0 +1,5 @@
+export declare const preferStringSchemaWithTrim: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"addTrim", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-string-schema-with-trim.d.ts

@@ -0,0 +1,5 @@
+export declare const preferStringSchemaWithTrim: import("@typescript-eslint/utils/ts-eslint").RuleModule<"addTrim", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};

package/dist/rules/prefer-string-schema-with-trim.js

@@ -0,0 +1,50 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('zod');
+export const preferStringSchemaWithTrim = createZodPluginRule({
+    name: 'prefer-string-schema-with-trim',
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            zodImportAllowedSource,
+            description: 'Enforce `z.string().trim()` to prevent accidental leading/trailing whitespace',
+        },
+        messages: {
+            addTrim: '`z.string()` schemas should use `.trim()`.',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
+        return {
+            ImportDeclaration: importDeclarationListener,
+            CallExpression(node) {
+                const zodSchemaMeta = detectZodSchemaRootNode(node);
+                if ((zodSchemaMeta === null || zodSchemaMeta === void 0 ? void 0 : zodSchemaMeta.schemaType) !== 'string') {
+                    return;
+                }
+                const methods = collectZodChainMethods(zodSchemaMeta.node);
+                if (methods.some((it) => it.name === 'trim')) {
+                    return;
+                }
+                if (zodSchemaMeta.schemaDecl === 'named') {
+                    context.report({
+                        node,
+                        messageId: 'addTrim',
+                    });
+                    return;
+                }
+                context.report({
+                    node,
+                    messageId: 'addTrim',
+                    fix(fixer) {
+                        const lastMethod = methods.at(0);
+                        return fixer.insertTextAfter(lastMethod.node, '.trim()');
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-brand-type-parameter.cjs

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireBrandTypeParameter = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.requireBrandTypeParameter = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.requireBrandTypeParameter = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'require-brand-type-parameter',
     meta: {
         hasSuggestions: true,
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Require type parameter on `.brand()` functions',
         },
         messages: {
@@ -20,7 +21,7 @@ exports.requireBrandTypeParameter = utils_1.ESLintUtils.RuleCreator(meta_js_1.ge
     },
     defaultOptions: [],
     create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

package/dist/rules/require-brand-type-parameter.d.cts

@@ -1,4 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], unknown, TSESLint.RuleListener> & {
+export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };

package/dist/rules/require-brand-type-parameter.d.ts

@@ -1,4 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], unknown, TSESLint.RuleListener> & {
+export declare const requireBrandTypeParameter: TSESLint.RuleModule<"missingTypeParameter" | "removeBrandFunction", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, TSESLint.RuleListener> & {
     name: string;
 };

package/dist/rules/require-brand-type-parameter.js

@@ -1,12 +1,13 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const requireBrandTypeParameter = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const requireBrandTypeParameter = createZodPluginRule({
     name: 'require-brand-type-parameter',
     meta: {
         hasSuggestions: true,
         type: 'problem',
         docs: {
+            zodImportAllowedSource,
             description: 'Require type parameter on `.brand()` functions',
         },
         messages: {

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

@@ -2,14 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireErrorMessage = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.requireErrorMessage = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.requireErrorMessage = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'require-error-message',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce that custom refinements include an error message',
         },
         messages: {
@@ -21,7 +23,7 @@ exports.requireErrorMessage = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleU
     },
     defaultOptions: [],
     create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             CallExpression(node) {

package/dist/rules/require-error-message.d.cts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const requireErrorMessage: ESLintUtils.RuleModule<"requireErrorMessage" | "preferError" | "removeMessage", [], unknown, ESLintUtils.RuleListener> & {
+export declare const requireErrorMessage: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"requireErrorMessage" | "preferError" | "removeMessage", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };

package/dist/rules/require-error-message.d.ts

@@ -1,4 +1,5 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const requireErrorMessage: ESLintUtils.RuleModule<"requireErrorMessage" | "preferError" | "removeMessage", [], unknown, ESLintUtils.RuleListener> & {
+export declare const requireErrorMessage: import("@typescript-eslint/utils/ts-eslint").RuleModule<"requireErrorMessage" | "preferError" | "removeMessage", [], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

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

@@ -1,12 +1,14 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const requireErrorMessage = ESLintUtils.RuleCreator(getRuleURL)({
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const requireErrorMessage = createZodPluginRule({
     name: 'require-error-message',
     meta: {
         type: 'suggestion',
         fixable: 'code',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce that custom refinements include an error message',
         },
         messages: {

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

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireSchemaSuffix = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.requireSchemaSuffix = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.requireSchemaSuffix = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'require-schema-suffix',
     meta: {
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Require schema suffix when declaring a Zod schema',
         },
         messages: {
@@ -29,7 +31,7 @@ exports.requireSchemaSuffix = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleU
     },
     defaultOptions: [{ suffix: 'Schema' }],
     create(context, [{ suffix }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         return {
             ImportDeclaration: importDeclarationListener,
             VariableDeclarator(node) {

package/dist/rules/require-schema-suffix.d.cts

@@ -1,8 +1,9 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 interface Options {
     suffix: string;
 }
-export declare const requireSchemaSuffix: ESLintUtils.RuleModule<"noSchemaSuffix", [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const requireSchemaSuffix: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<"noSchemaSuffix", [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/require-schema-suffix.d.ts

@@ -1,8 +1,9 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 interface Options {
     suffix: string;
 }
-export declare const requireSchemaSuffix: ESLintUtils.RuleModule<"noSchemaSuffix", [Options], unknown, ESLintUtils.RuleListener> & {
+export declare const requireSchemaSuffix: import("@typescript-eslint/utils/ts-eslint").RuleModule<"noSchemaSuffix", [Options], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export {};

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

@@ -1,11 +1,13 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const requireSchemaSuffix = ESLintUtils.RuleCreator(getRuleURL)({
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const requireSchemaSuffix = createZodPluginRule({
     name: 'require-schema-suffix',
     meta: {
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Require schema suffix when declaring a Zod schema',
         },
         messages: {

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

@@ -6,13 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schemaErrorPropertyStyle = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const esquery_1 = __importDefault(require("esquery"));
-const meta_js_1 = require("../meta.cjs");
+const create_plugin_rule_js_1 = require("../utils/create-plugin-rule.cjs");
 const track_zod_schema_imports_js_1 = require("../utils/track-zod-schema-imports.cjs");
-exports.schemaErrorPropertyStyle = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL)({
+const { zodImportAllowedSource, trackZodSchemaImports, } = (0, track_zod_schema_imports_js_1.createZodSchemaImportTrack)('all');
+exports.schemaErrorPropertyStyle = (0, create_plugin_rule_js_1.createZodPluginRule)({
     name: 'schema-error-property-style',
     meta: {
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)',
         },
         messages: {
@@ -40,7 +42,7 @@ exports.schemaErrorPropertyStyle = utils_1.ESLintUtils.RuleCreator(meta_js_1.get
         { selector: 'Literal,TemplateLiteral', example: "'error message'" },
     ],
     create(context, [{ selector, example }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = (0, track_zod_schema_imports_js_1.trackZodSchemaImports)();
+        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
         try {
             esquery_1.default.parse(selector);
         }

package/dist/rules/schema-error-property-style.d.cts

@@ -1,9 +1,10 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 type MessageIds = 'invalidStyle' | 'invalidSelector';
-export declare const schemaErrorPropertyStyle: ESLintUtils.RuleModule<MessageIds, [{
+export declare const schemaErrorPropertyStyle: import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<MessageIds, [{
     selector: string;
     example: string;
-}], unknown, ESLintUtils.RuleListener> & {
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener> & {
     name: string;
 };
 export {};

package/dist/rules/schema-error-property-style.d.ts

@@ -1,9 +1,10 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
 type MessageIds = 'invalidStyle' | 'invalidSelector';
-export declare const schemaErrorPropertyStyle: ESLintUtils.RuleModule<MessageIds, [{
+export declare const schemaErrorPropertyStyle: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [{
     selector: string;
     example: string;
-}], unknown, ESLintUtils.RuleListener> & {
+}], {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };
 export {};

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

@@ -1,12 +1,14 @@
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import esquery from 'esquery';
-import { getRuleURL } from "../meta.js";
-import { trackZodSchemaImports } from "../utils/track-zod-schema-imports.js";
-export const schemaErrorPropertyStyle = ESLintUtils.RuleCreator(getRuleURL)({
+import { createZodPluginRule } from "../utils/create-plugin-rule.js";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.js";
+const { zodImportAllowedSource, trackZodSchemaImports, } = createZodSchemaImportTrack('all');
+export const schemaErrorPropertyStyle = createZodPluginRule({
     name: 'schema-error-property-style',
     meta: {
         type: 'suggestion',
         docs: {
+            zodImportAllowedSource,
             description: 'Enforce consistent style for error messages in Zod schema validation (using ESQuery patterns)',
         },
         messages: {

package/dist/utils/build-zod-chain-replacement-fix.cjs

@@ -19,6 +19,13 @@ function buildZodChainReplacementFix(opts) {
         const fullText = sourceCode.getText(m.node);
         return fullText.slice(objText.length);
     });
-    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    let replacement = `${prefixText}.${toMethodName}(`;
+    if (toNode.arguments.length) {
+        const argsText = toNode.arguments
+            .map((arg) => sourceCode.getText(arg))
+            .join(', ');
+        replacement += argsText;
+    }
+    replacement += `)${betweenSuffixes.join('')}`;
     return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
 }

package/dist/utils/build-zod-chain-replacement-fix.js

@@ -16,6 +16,13 @@ export function buildZodChainReplacementFix(opts) {
         const fullText = sourceCode.getText(m.node);
         return fullText.slice(objText.length);
     });
-    const replacement = `${prefixText}.${toMethodName}()${betweenSuffixes.join('')}`;
+    let replacement = `${prefixText}.${toMethodName}(`;
+    if (toNode.arguments.length) {
+        const argsText = toNode.arguments
+            .map((arg) => sourceCode.getText(arg))
+            .join(', ');
+        replacement += argsText;
+    }
+    replacement += `)${betweenSuffixes.join('')}`;
     return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
 }

package/dist/utils/create-plugin-rule.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createZodPluginRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const meta_js_1 = require("../meta.cjs");
+exports.createZodPluginRule = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL);

package/dist/utils/create-plugin-rule.d.cts

@@ -0,0 +1,13 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { ZodImportAllowedSource } from "./is-zod-import-source.cjs";
+export type ZodPluginRule = ESLintUtils.RuleWithMetaAndName<[
+], string, {
+    zodImportAllowedSource: ZodImportAllowedSource;
+}>;
+export declare const createZodPluginRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}>>) => ESLintUtils.RuleModule<MessageIds, Options, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/utils/create-plugin-rule.d.ts

@@ -0,0 +1,13 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import type { ZodImportAllowedSource } from "./is-zod-import-source.js";
+export type ZodPluginRule = ESLintUtils.RuleWithMetaAndName<[
+], string, {
+    zodImportAllowedSource: ZodImportAllowedSource;
+}>;
+export declare const createZodPluginRule: <Options extends readonly unknown[], MessageIds extends string>({ meta, name, ...rule }: Readonly<ESLintUtils.RuleWithMetaAndName<Options, MessageIds, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}>>) => ESLintUtils.RuleModule<MessageIds, Options, {
+    zodImportAllowedSource: "all" | "zod" | "zod-mini";
+}, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/utils/create-plugin-rule.js

@@ -0,0 +1,3 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getRuleURL } from "../meta.js";
+export const createZodPluginRule = ESLintUtils.RuleCreator(getRuleURL);