eslint-plugin-zod 3.5.0 → 3.5.2

package/dist/rules/array-style.mjs

@@ -0,0 +1,89 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/array-style.ts
+const ZOD_ARRAY_STYLES = ["function", "method"];
+const defaultOptions = { style: "function" };
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const arrayStyle = createZodPluginRule({
+	name: "array-style",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			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)."
+		},
+		schema: [{
+			type: "object",
+			properties: { style: {
+				description: "Decides which style for zod array function",
+				type: "string",
+				enum: ZOD_ARRAY_STYLES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [defaultOptions],
+	create(context, [{ style }]) {
+		const { sourceCode } = context;
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchema = detectZodSchemaRootNode(node);
+				if (!zodSchema) return;
+				const { schemaDecl, schemaType } = zodSchema;
+				if (style === "method") {
+					if (schemaType === "array") {
+						if (schemaDecl === "namespace") {
+							context.report({
+								node,
+								messageId: "useMethod",
+								fix(fixer) {
+									const arrayCall = collectZodChainMethods(node).find((c) => c.name === "array");
+									if (!arrayCall) return null;
+									const arg = arrayCall.node.arguments.at(0);
+									if (!arg) return null;
+									const argText = sourceCode.getText(arg);
+									return fixer.replaceText(arrayCall.node, `${argText}.array()`);
+								}
+							});
+							return;
+						}
+						context.report({
+							node,
+							messageId: "useMethod"
+						});
+					}
+					return;
+				}
+				const arrayMethod = collectZodChainMethods(node).find((it) => it.name === "array" && it.node.arguments.length === 0);
+				if (arrayMethod) {
+					const arrayNode = arrayMethod.node;
+					if (schemaDecl === "namespace") {
+						context.report({
+							node,
+							messageId: "useFunction",
+							fix(fixer) {
+								const callee = arrayNode.callee;
+								const objText = sourceCode.getText(callee.object);
+								return fixer.replaceText(arrayNode, `z.array(${objText})`);
+							}
+						});
+						return;
+					}
+					context.report({
+						node,
+						messageId: "useFunction"
+					});
+				}
+			}
+		};
+	}
+});
+//#endregion
+export { arrayStyle };

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

@@ -1,67 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.consistentImportSource = void 0;
-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");
-exports.consistentImportSource = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'consistent-import-source',
-    meta: {
-        hasSuggestions: true,
-        type: 'suggestion',
-        docs: {
-            zodImportAllowedSource: 'all',
-            description: 'Enforce consistent source from Zod imports',
-        },
-        messages: {
-            sourceNotAllowed: '"{{source}}" is not allowed. Available values are: {{sources}}',
-            replaceSource: 'Replace "{{invalid}}" with "{{valid}}"',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    sources: {
-                        type: 'array',
-                        description: 'An array of allowed Zod import sources.',
-                        items: {
-                            type: 'string',
-                            enum: [...is_zod_import_source_js_1.ZOD_IMPORT_SOURCES],
-                        },
-                        minItems: 1,
-                        uniqueItems: true,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [{ sources: ['zod'] }],
-    create(context, [{ sources }]) {
-        return {
-            ImportDeclaration(node) {
-                const sourceValue = node.source.value;
-                if (!sourceValue.startsWith('zod')) {
-                    return;
-                }
-                if (sources.includes(sourceValue)) {
-                    return;
-                }
-                context.report({
-                    node,
-                    messageId: 'sourceNotAllowed',
-                    data: {
-                        source: sourceValue,
-                        sources: sources.map((s) => `"${s}"`).join(', '),
-                    },
-                    suggest: sources.map((it) => ({
-                        messageId: 'replaceSource',
-                        data: { valid: it, invalid: sourceValue },
-                        fix(fixer) {
-                            return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
-                        },
-                    })),
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+const require_is_zod_import_source = require("../utils/is-zod-import-source.cjs");
+//#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"
+		},
+		messages: {
+			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
+			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { sources: {
+				type: "array",
+				description: "An array of allowed Zod import sources.",
+				items: {
+					type: "string",
+					enum: [...require_is_zod_import_source.ZOD_IMPORT_SOURCES]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ sources: ["zod"] }],
+	create(context, [{ sources }]) {
+		return { ImportDeclaration(node) {
+			const sourceValue = node.source.value;
+			if (!sourceValue.startsWith("zod")) return;
+			if (sources.includes(sourceValue)) return;
+			context.report({
+				node,
+				messageId: "sourceNotAllowed",
+				data: {
+					source: sourceValue,
+					sources: sources.map((s) => `"${s}"`).join(", ")
+				},
+				suggest: sources.map((it) => ({
+					messageId: "replaceSource",
+					data: {
+						valid: it,
+						invalid: sourceValue
+					},
+					fix(fixer) {
+						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
+					}
+				}))
+			});
+		} };
+	}
 });
+//#endregion
+exports.consistentImportSource = consistentImportSource;

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

@@ -0,0 +1,60 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { ZOD_IMPORT_SOURCES } from "../utils/is-zod-import-source.mjs";
+//#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"
+		},
+		messages: {
+			sourceNotAllowed: "\"{{source}}\" is not allowed. Available values are: {{sources}}",
+			replaceSource: "Replace \"{{invalid}}\" with \"{{valid}}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { sources: {
+				type: "array",
+				description: "An array of allowed Zod import sources.",
+				items: {
+					type: "string",
+					enum: [...ZOD_IMPORT_SOURCES]
+				},
+				minItems: 1,
+				uniqueItems: true
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ sources: ["zod"] }],
+	create(context, [{ sources }]) {
+		return { ImportDeclaration(node) {
+			const sourceValue = node.source.value;
+			if (!sourceValue.startsWith("zod")) return;
+			if (sources.includes(sourceValue)) return;
+			context.report({
+				node,
+				messageId: "sourceNotAllowed",
+				data: {
+					source: sourceValue,
+					sources: sources.map((s) => `"${s}"`).join(", ")
+				},
+				suggest: sources.map((it) => ({
+					messageId: "replaceSource",
+					data: {
+						valid: it,
+						invalid: sourceValue
+					},
+					fix(fixer) {
+						return fixer.replaceText(node.source, node.source.raw.replace(sourceValue, it));
+					}
+				}))
+			});
+		} };
+	}
+});
+//#endregion
+export { consistentImportSource };

package/dist/rules/consistent-import.cjs

@@ -1,179 +1,153 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.consistentImport = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-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");
-const IMPORT_SYNTAXES = ['namespace', 'named'];
+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");
+//#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;
-    const isValidForSyntax = syntax === 'named'
-        ? specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-            specifier.imported.name === 'z'
-        : specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier;
-    if (!isValidForSyntax) {
-        return false;
-    }
-    if (hasOnlyTypeImports) {
-        return importKind === 'type';
-    }
-    return true;
+	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 === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-        return false;
-    }
-    if (node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-        node.parent.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.parent.object.name !== node.name) {
-        return false;
-    }
-    return true;
+	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 === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
-        node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-        return node.local.name;
-    }
-    if (node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-        node.imported.name === 'z') {
-        return node.local.name;
-    }
-    return null;
+	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;
 }
-exports.consistentImport = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'consistent-import',
-    meta: {
-        type: 'problem',
-        docs: {
-            zodImportAllowedSource: 'all',
-            description: 'Enforce a consistent import style for Zod',
-        },
-        fixable: 'code',
-        messages: {
-            changeImportSyntax: 'Use a {{syntax}} import for Zod.',
-            removeDuplicate: 'Remove duplicate Zod import; Zod is already imported.',
-            convertUsage: 'Update Zod usage to match the {{syntax}} import syntax.',
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    syntax: {
-                        description: 'Specifies the import syntax to use for Zod.',
-                        type: 'string',
-                        enum: IMPORT_SYNTAXES,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-    defaultOptions: [{ syntax: 'namespace' }],
-    create(context, [options]) {
-        const { syntax } = options;
-        const { sourceCode } = context;
-        const importGroups = {};
-        return {
-            ImportDeclaration(node) {
-                const { source, importKind } = node;
-                if (!(0, is_zod_import_source_js_1.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;
-                    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;
-                        }
-                    }
-                    const isFirstImportValid = isGroupFirstImportKindValidForSyntax(importGroup, syntax);
-                    if (!isFirstImportValid) {
-                        context.report({
-                            node: firstImportNode,
-                            messageId: 'changeImportSyntax',
-                            data: { syntax },
-                            fix(fixer) {
-                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
-                                let importSpecifier;
-                                if (syntax === 'named') {
-                                    if (namespaceAliasName === 'z') {
-                                        importSpecifier = '{ z }';
-                                    }
-                                    else {
-                                        importSpecifier = `{ z as ${namespaceAliasName} }`;
-                                    }
-                                }
-                                else {
-                                    importSpecifier = `* as ${namespaceAliasName}`;
-                                }
-                                const newImportText = `import ${importTypeKeyword}${importSpecifier} from ${firstImportNode.source.raw};`;
-                                return fixer.replaceText(firstImportNode, newImportText);
-                            },
-                        });
-                    }
-                    const allVariables = nodesWithVariablesToUpdate.flatMap((it) => sourceCode.getDeclaredVariables(it));
-                    const allReferences = allVariables.flatMap((it) => it.references);
-                    for (const ref of allReferences) {
-                        const { identifier } = ref;
-                        if (shouldIdentifierBeRenamed(identifier)) {
-                            context.report({
-                                node: identifier,
-                                messageId: 'convertUsage',
-                                data: { syntax },
-                                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);
-                            },
-                        });
-                    }
-                }
-            },
-        };
-    },
+const consistentImport = require_create_plugin_rule.createZodPluginRule({
+	name: "consistent-import",
+	meta: {
+		type: "problem",
+		docs: {
+			zodImportAllowedSource: "all",
+			description: "Enforce a consistent import style for Zod"
+		},
+		fixable: "code",
+		messages: {
+			changeImportSyntax: "Use a {{syntax}} import for Zod.",
+			removeDuplicate: "Remove duplicate Zod import; Zod is already imported.",
+			convertUsage: "Update Zod usage to match the {{syntax}} import syntax."
+		},
+		schema: [{
+			type: "object",
+			properties: { syntax: {
+				description: "Specifies the import syntax to use for Zod.",
+				type: "string",
+				enum: IMPORT_SYNTAXES
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ syntax: "namespace" }],
+	create(context, [options]) {
+		const { syntax } = options;
+		const { sourceCode } = context;
+		const importGroups = {};
+		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] = {
+					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 (!isGroupFirstImportKindValidForSyntax(importGroup, syntax)) context.report({
+						node: firstImportNode,
+						messageId: "changeImportSyntax",
+						data: { syntax },
+						fix(fixer) {
+							const importTypeKeyword = hasOnlyTypeImports ? "type " : "";
+							let importSpecifier;
+							if (syntax === "named") if (namespaceAliasName === "z") importSpecifier = "{ z }";
+							else importSpecifier = `{ z as ${namespaceAliasName} }`;
+							else importSpecifier = `* as ${namespaceAliasName}`;
+							const newImportText = `import ${importTypeKeyword}${importSpecifier} 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",
+							data: { syntax },
+							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
+exports.consistentImport = consistentImport;