eslint-plugin-zod 3.5.1 → 3.5.2

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

@@ -0,0 +1,116 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { isZodImportSource } from "../utils/is-zod-import-source.mjs";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/rules/prefer-namespace-import.ts
+function isGroupFirstImportTypeNamespace(group) {
+	const { hasOnlyTypeImports, nodes: [firstImportNode] } = group;
+	const { specifiers } = firstImportNode;
+	if (specifiers.length === 1 && specifiers[0].type === AST_NODE_TYPES.ImportNamespaceSpecifier) if (hasOnlyTypeImports) {
+		if (firstImportNode.importKind === "type") return true;
+	} else return true;
+	return false;
+}
+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 preferNamespaceImport = createZodPluginRule({
+	name: "prefer-namespace-import",
+	meta: {
+		type: "suggestion",
+		deprecated: { 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",
+		messages: {
+			useNamespace: "Import Zod with a namespace import",
+			removeDuplicate: "Zod is already imported via namespace import",
+			convertUsage: "Convert to namespace usage"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { sourceCode } = context;
+		const importGroups = {};
+		return {
+			ImportDeclaration(node) {
+				const { source, importKind } = node;
+				if (!isZodImportSource(source.value, "all")) return;
+				if (!importGroups[source.value]) importGroups[source.value] = {
+					hasOnlyTypeImports: true,
+					nodes: []
+				};
+				if (importGroups[source.value].hasOnlyTypeImports && importKind === "value") importGroups[source.value].hasOnlyTypeImports = false;
+				importGroups[source.value].nodes.push(node);
+			},
+			"Program:exit": function() {
+				let namespaceAliasNameIndex = 0;
+				for (const importGroup of Object.values(importGroups)) {
+					const { hasOnlyTypeImports, nodes } = importGroup;
+					const [firstImportNode, ...othersImportNodes] = nodes;
+					/**
+					* Variable to track all specifiers that later are used by {@link getDeclaredVariables}
+					* to add the namespace prefix
+					*/
+					const nodesWithVariablesToUpdate = [];
+					let namespaceAliasName = null;
+					for (const specifier of nodes.flatMap((it) => it.specifiers)) {
+						if (!namespaceAliasName) {
+							namespaceAliasName = getNamespaceAliasNameFrom(specifier);
+							if (namespaceAliasName) continue;
+						}
+						nodesWithVariablesToUpdate.push(specifier);
+					}
+					if (!namespaceAliasName) {
+						namespaceAliasName = "z";
+						if (namespaceAliasNameIndex > 0) {
+							namespaceAliasName = `z${namespaceAliasNameIndex}`;
+							namespaceAliasNameIndex += 1;
+						}
+					}
+					if (!isGroupFirstImportTypeNamespace(importGroup)) context.report({
+						node: firstImportNode,
+						messageId: "useNamespace",
+						fix(fixer) {
+							const newImportText = `import ${hasOnlyTypeImports ? "type " : ""}* as ${namespaceAliasName} from ${firstImportNode.source.raw};`;
+							return fixer.replaceText(firstImportNode, newImportText);
+						}
+					});
+					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({
+							node: identifier,
+							messageId: "convertUsage",
+							fix(fixer) {
+								const newId = `${namespaceAliasName}.${identifier.name}`;
+								return fixer.replaceText(identifier, newId);
+							}
+						});
+					}
+					for (const extraImport of othersImportNodes) context.report({
+						node: extraImport,
+						messageId: "removeDuplicate",
+						fix(fixer) {
+							return fixer.removeRange(extraImport.range);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { preferNamespaceImport };

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

@@ -1,53 +1,46 @@
-"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()');
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/prefer-string-schema-with-trim.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("zod");
+const preferStringSchemaWithTrim = require_create_plugin_rule.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?.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()");
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.preferStringSchemaWithTrim = preferStringSchemaWithTrim;

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

@@ -0,0 +1,47 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/prefer-string-schema-with-trim.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+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?.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()");
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferStringSchemaWithTrim };

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

@@ -1,61 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireBrandTypeParameter = 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)('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: {
-            missingTypeParameter: 'Type parameter is required when using `.brand()`',
-            removeBrandFunction: 'Brand is a static-only construct. If not parameter is required consider removal',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                const methods = collectZodChainMethods(zodSchemaMeta.node);
-                const brandMethod = methods.find((it) => it.name === 'brand');
-                if (!brandMethod) {
-                    return;
-                }
-                const brandNode = brandMethod.node;
-                const { typeArguments } = brandNode;
-                if (typeArguments && typeArguments.params.length > 0) {
-                    return;
-                }
-                const brandCalleeNode = brandNode.callee;
-                context.report({
-                    messageId: 'missingTypeParameter',
-                    node: brandCalleeNode.property,
-                    suggest: [
-                        {
-                            messageId: 'removeBrandFunction',
-                            fix(fixer) {
-                                return fixer.removeRange([
-                                    brandCalleeNode.object.range[1],
-                                    brandNode.range[1],
-                                ]);
-                            },
-                        },
-                    ],
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/require-brand-type-parameter.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("all");
+const requireBrandTypeParameter = require_create_plugin_rule.createZodPluginRule({
+	name: "require-brand-type-parameter",
+	meta: {
+		hasSuggestions: true,
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Require type parameter on `.brand()` functions"
+		},
+		messages: {
+			missingTypeParameter: "Type parameter is required when using `.brand()`",
+			removeBrandFunction: "Brand is a static-only construct. If not parameter is required consider removal"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const brandMethod = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "brand");
+				if (!brandMethod) return;
+				const brandNode = brandMethod.node;
+				const { typeArguments } = brandNode;
+				if (typeArguments && typeArguments.params.length > 0) return;
+				const brandCalleeNode = brandNode.callee;
+				context.report({
+					messageId: "missingTypeParameter",
+					node: brandCalleeNode.property,
+					suggest: [{
+						messageId: "removeBrandFunction",
+						fix(fixer) {
+							return fixer.removeRange([brandCalleeNode.object.range[1], brandNode.range[1]]);
+						}
+					}]
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.requireBrandTypeParameter = requireBrandTypeParameter;

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

@@ -0,0 +1,49 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/require-brand-type-parameter.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const requireBrandTypeParameter = createZodPluginRule({
+	name: "require-brand-type-parameter",
+	meta: {
+		hasSuggestions: true,
+		type: "problem",
+		docs: {
+			zodImportAllowedSource,
+			description: "Require type parameter on `.brand()` functions"
+		},
+		messages: {
+			missingTypeParameter: "Type parameter is required when using `.brand()`",
+			removeBrandFunction: "Brand is a static-only construct. If not parameter is required consider removal"
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const brandMethod = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "brand");
+				if (!brandMethod) return;
+				const brandNode = brandMethod.node;
+				const { typeArguments } = brandNode;
+				if (typeArguments && typeArguments.params.length > 0) return;
+				const brandCalleeNode = brandNode.callee;
+				context.report({
+					messageId: "missingTypeParameter",
+					node: brandCalleeNode.property,
+					suggest: [{
+						messageId: "removeBrandFunction",
+						fix(fixer) {
+							return fixer.removeRange([brandCalleeNode.object.range[1], brandNode.range[1]]);
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { requireBrandTypeParameter };

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

@@ -1,103 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireErrorMessage = 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.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: {
-            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) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    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 === utils_1.AST_NODE_TYPES.Literal) {
-                    return;
-                }
-                if (params.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    let errorPropertyNode;
-                    let messagePropertyNode;
-                    for (const property of params.properties) {
-                        if (property.type === utils_1.AST_NODE_TYPES.Property &&
-                            property.key.type === utils_1.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 === null || nextToken === void 0 ? void 0 : 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,
-                        });
-                    }
-                }
-            },
-        };
-    },
+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-error-message.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require_track_zod_schema_imports.createZodSchemaImportTrack("all");
+const requireErrorMessage = require_create_plugin_rule.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 === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return;
+				if (params.type === _typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression) {
+					let errorPropertyNode;
+					let messagePropertyNode;
+					for (const property of params.properties) if (property.type === _typescript_eslint_utils.AST_NODE_TYPES.Property && property.key.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+						if (property.key.name === "error") errorPropertyNode = property;
+						if (property.key.name === "message") messagePropertyNode = property;
+						if (errorPropertyNode && messagePropertyNode) break;
+					}
+					if (errorPropertyNode && messagePropertyNode) {
+						context.report({
+							messageId: "removeMessage",
+							node: messagePropertyNode,
+							fix(fixer) {
+								const { sourceCode } = context;
+								const nextToken = sourceCode.getTokenAfter(messagePropertyNode);
+								let [, end] = messagePropertyNode.range;
+								if (nextToken?.value === ",") end = nextToken.range[1];
+								return fixer.removeRange([messagePropertyNode.range[0], end]);
+							}
+						});
+						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
+exports.requireErrorMessage = requireErrorMessage;