eslint-plugin-zod 3.5.1 → 3.5.2

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

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

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

@@ -1,79 +1,68 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireSchemaSuffix = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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)('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: {
-            noSchemaSuffix: 'Use the "{{suffix}}" suffix for Zod schemas. Rename this to "{{expected}}"',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    suffix: {
-                        type: 'string',
-                        description: 'The required suffix for Zod schema variables',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [{ suffix: 'Schema' }],
-    create(context, [{ suffix }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            VariableDeclarator(node) {
-                const initNode = node.init;
-                if ((initNode === null || initNode === void 0 ? void 0 : initNode.type) !== utils_1.AST_NODE_TYPES.CallExpression ||
-                    !detectZodSchemaRootNode(initNode)) {
-                    return;
-                }
-                const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
-                const methodsThatProduceSomethingThatShouldNotBeValidated = [
-                    'parse',
-                    'parseAsync',
-                    'safeParse',
-                    'safeParseAsync',
-                    'spa',
-                    'encode',
-                    'encodeAsync',
-                    'decode',
-                    'decodeAsync',
-                    'safeEncode',
-                    'safeEncodeAsync',
-                    'safeDecode',
-                    'safeDecodeAsync',
-                    'codec',
-                    'treeifyError',
-                    'prettifyError',
-                    'formatError',
-                    'flattenError',
-                ];
-                if (methodsThatProduceSomethingThatShouldNotBeValidated.some((it) => chainMethods.includes(it))) {
-                    return;
-                }
-                if (node.id.type !== utils_1.AST_NODE_TYPES.Identifier ||
-                    node.id.name.endsWith(suffix)) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: 'noSchemaSuffix',
-                    data: { suffix, expected: `${node.id.name}${suffix}` },
-                });
-            },
-        };
-    },
+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 _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/rules/require-schema-suffix.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const requireSchemaSuffix = require_create_plugin_rule.createZodPluginRule({
+	name: "require-schema-suffix",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Require schema suffix when declaring a Zod schema"
+		},
+		messages: { noSchemaSuffix: "Use the \"{{suffix}}\" suffix for Zod schemas. Rename this to \"{{expected}}\"" },
+		schema: [{
+			type: "object",
+			properties: { suffix: {
+				type: "string",
+				description: "The required suffix for Zod schema variables"
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ suffix: "Schema" }],
+	create(context, [{ suffix }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			VariableDeclarator(node) {
+				const initNode = node.init;
+				if (initNode?.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression || !detectZodSchemaRootNode(initNode)) return;
+				const chainMethods = collectZodChainMethods(initNode).map((it) => it.name);
+				if ([
+					"parse",
+					"parseAsync",
+					"safeParse",
+					"safeParseAsync",
+					"spa",
+					"encode",
+					"encodeAsync",
+					"decode",
+					"decodeAsync",
+					"safeEncode",
+					"safeEncodeAsync",
+					"safeDecode",
+					"safeDecodeAsync",
+					"codec",
+					"treeifyError",
+					"prettifyError",
+					"formatError",
+					"flattenError"
+				].some((it) => chainMethods.includes(it))) return;
+				if (node.id.type !== _typescript_eslint_utils.AST_NODE_TYPES.Identifier || node.id.name.endsWith(suffix)) return;
+				context.report({
+					node,
+					messageId: "noSchemaSuffix",
+					data: {
+						suffix,
+						expected: `${node.id.name}${suffix}`
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.requireSchemaSuffix = requireSchemaSuffix;

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

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

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

@@ -1,108 +1,96 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schemaErrorPropertyStyle = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const esquery_1 = __importDefault(require("esquery"));
-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)('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: {
-            invalidSelector: 'Invalid ESQuery selector: "{{selector}}"',
-            invalidStyle: 'Error message must follow the pattern "{{selector}}" (e.g., {{example}}). Found: {{actual}}.',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    selector: {
-                        description: 'An ESQuery string to match the required pattern',
-                        type: 'string',
-                    },
-                    example: {
-                        description: 'Example code to help the user understand the required pattern',
-                        type: 'string',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [
-        { selector: 'Literal,TemplateLiteral', example: "'error message'" },
-    ],
-    create(context, [{ selector, example }]) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        try {
-            esquery_1.default.parse(selector);
-        }
-        catch (_a) {
-            context.report({
-                loc: { line: 1, column: 0 },
-                messageId: 'invalidSelector',
-                data: { selector },
-            });
-            return {};
-        }
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                if (zodSchemaMeta.schemaType !== 'custom' &&
-                    !collectZodChainMethods(node).some((it) => it.name === 'refine')) {
-                    return;
-                }
-                if (node.arguments.length < 2) {
-                    return;
-                }
-                let errorMessageNode;
-                const [, params] = node.arguments;
-                switch (params.type) {
-                    case utils_1.AST_NODE_TYPES.Literal:
-                    case utils_1.AST_NODE_TYPES.TemplateLiteral:
-                        errorMessageNode = params;
-                        break;
-                    case utils_1.AST_NODE_TYPES.ObjectExpression:
-                        for (const property of params.properties) {
-                            if (property.type === utils_1.AST_NODE_TYPES.Property &&
-                                property.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                property.key.name === 'error') {
-                                errorMessageNode = property.value;
-                                break;
-                            }
-                        }
-                        break;
-                }
-                if (!errorMessageNode) {
-                    return;
-                }
-                const match = esquery_1.default.matches(errorMessageNode, esquery_1.default.parse(selector), errorMessageNode);
-                if (match) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: 'invalidStyle',
-                    data: {
-                        selector,
-                        example,
-                        actual: context.sourceCode.getText(errorMessageNode),
-                    },
-                });
-            },
-        };
-    },
+const require_runtime = 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 _typescript_eslint_utils = require("@typescript-eslint/utils");
+let esquery = require("esquery");
+esquery = require_runtime.__toESM(esquery);
+//#region src/rules/schema-error-property-style.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const schemaErrorPropertyStyle = require_create_plugin_rule.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: {
+			invalidSelector: "Invalid ESQuery selector: \"{{selector}}\"",
+			invalidStyle: "Error message must follow the pattern \"{{selector}}\" (e.g., {{example}}). Found: {{actual}}."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				selector: {
+					description: "An ESQuery string to match the required pattern",
+					type: "string"
+				},
+				example: {
+					description: "Example code to help the user understand the required pattern",
+					type: "string"
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{
+		selector: "Literal,TemplateLiteral",
+		example: "'error message'"
+	}],
+	create(context, [{ selector, example }]) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		/**
+		* Parsing `selector` to ensure it is valid,
+		* if not report an error and return empty rule listener
+		*/
+		try {
+			esquery.default.parse(selector);
+		} catch {
+			context.report({
+				loc: {
+					line: 1,
+					column: 0
+				},
+				messageId: "invalidSelector",
+				data: { selector }
+			});
+			return {};
+		}
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				if (zodSchemaMeta.schemaType !== "custom" && !collectZodChainMethods(node).some((it) => it.name === "refine")) return;
+				if (node.arguments.length < 2) return;
+				let errorMessageNode;
+				const [, params] = node.arguments;
+				switch (params.type) {
+					case _typescript_eslint_utils.AST_NODE_TYPES.Literal:
+					case _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral:
+						errorMessageNode = params;
+						break;
+					case _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression:
+						for (const property of params.properties) if (property.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && property.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier && property.key.name === "error") {
+							errorMessageNode = property.value;
+							break;
+						}
+						break;
+				}
+				if (!errorMessageNode) return;
+				if (esquery.default.matches(errorMessageNode, esquery.default.parse(selector), errorMessageNode)) return;
+				context.report({
+					node,
+					messageId: "invalidStyle",
+					data: {
+						selector,
+						example,
+						actual: context.sourceCode.getText(errorMessageNode)
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.schemaErrorPropertyStyle = schemaErrorPropertyStyle;

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

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