eslint-plugin-zod 3.5.1 → 3.5.2

package/dist/rules/prefer-meta-last.cjs

@@ -1,64 +1,48 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferMetaLast = 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.preferMetaLast = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'prefer-meta-last',
-    meta: {
-        type: 'suggestion',
-        docs: {
-            zodImportAllowedSource,
-            description: 'Enforce `.meta()` as last method',
-        },
-        fixable: 'code',
-        messages: {
-            metaNotLast: 'The `.meta()` methods should be the last one called',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                const chain = collectZodChainMethods(node);
-                const metaIndex = chain.findIndex((c) => c.name === 'meta');
-                if (metaIndex === -1) {
-                    return;
-                }
-                const hasAnyNonMetaAfter = chain
-                    .slice(metaIndex + 1)
-                    .some((c) => c.name !== 'meta');
-                if (!hasAnyNonMetaAfter) {
-                    return;
-                }
-                const metaCall = chain[metaIndex].node;
-                const metaCallCallee = metaCall.callee;
-                context.report({
-                    node: metaCallCallee.property,
-                    messageId: 'metaNotLast',
-                    fix(fixer) {
-                        const source = context.sourceCode;
-                        const metaCallText = source.getText(metaCall);
-                        const objectText = source.getText(metaCallCallee.object);
-                        const onlyMetaSuffix = metaCallText.slice(objectText.length);
-                        const [, removeStart] = metaCallCallee.object.range;
-                        const [, removeEnd] = metaCall.range;
-                        const lastCall = chain[chain.length - 1].node;
-                        return [
-                            fixer.removeRange([removeStart, removeEnd]),
-                            fixer.insertTextAfterRange(lastCall.range, onlyMetaSuffix),
-                        ];
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/prefer-meta-last.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("zod");
+const preferMetaLast = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-meta-last",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce `.meta()` as last method"
+		},
+		fixable: "code",
+		messages: { metaNotLast: "The `.meta()` methods should be the last one called" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const chain = collectZodChainMethods(node);
+				const metaIndex = chain.findIndex((c) => c.name === "meta");
+				if (metaIndex === -1) return;
+				if (!chain.slice(metaIndex + 1).some((c) => c.name !== "meta")) return;
+				const metaCall = chain[metaIndex].node;
+				const metaCallCallee = metaCall.callee;
+				context.report({
+					node: metaCallCallee.property,
+					messageId: "metaNotLast",
+					fix(fixer) {
+						const source = context.sourceCode;
+						const metaCallText = source.getText(metaCall);
+						const objectText = source.getText(metaCallCallee.object);
+						const onlyMetaSuffix = metaCallText.slice(objectText.length);
+						const [, removeStart] = metaCallCallee.object.range;
+						const [, removeEnd] = metaCall.range;
+						const lastCall = chain[chain.length - 1].node;
+						return [fixer.removeRange([removeStart, removeEnd]), fixer.insertTextAfterRange(lastCall.range, onlyMetaSuffix)];
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.preferMetaLast = preferMetaLast;

package/dist/rules/prefer-meta-last.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/prefer-meta-last.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("zod");
+const preferMetaLast = createZodPluginRule({
+	name: "prefer-meta-last",
+	meta: {
+		type: "suggestion",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce `.meta()` as last method"
+		},
+		fixable: "code",
+		messages: { metaNotLast: "The `.meta()` methods should be the last one called" },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				if (!detectZodSchemaRootNode(node)) return;
+				const chain = collectZodChainMethods(node);
+				const metaIndex = chain.findIndex((c) => c.name === "meta");
+				if (metaIndex === -1) return;
+				if (!chain.slice(metaIndex + 1).some((c) => c.name !== "meta")) return;
+				const metaCall = chain[metaIndex].node;
+				const metaCallCallee = metaCall.callee;
+				context.report({
+					node: metaCallCallee.property,
+					messageId: "metaNotLast",
+					fix(fixer) {
+						const source = context.sourceCode;
+						const metaCallText = source.getText(metaCall);
+						const objectText = source.getText(metaCallCallee.object);
+						const onlyMetaSuffix = metaCallText.slice(objectText.length);
+						const [, removeStart] = metaCallCallee.object.range;
+						const [, removeEnd] = metaCall.range;
+						const lastCall = chain[chain.length - 1].node;
+						return [fixer.removeRange([removeStart, removeEnd]), fixer.insertTextAfterRange(lastCall.range, onlyMetaSuffix)];
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferMetaLast };

package/dist/rules/prefer-meta.cjs

@@ -1,49 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferMeta = 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.preferMeta = (0, create_plugin_rule_js_1.createZodPluginRule)({
-    name: 'prefer-meta',
-    meta: {
-        type: 'suggestion',
-        fixable: 'code',
-        docs: {
-            zodImportAllowedSource,
-            description: 'Enforce usage of `.meta()` over `.describe()`',
-        },
-        messages: {
-            preferMeta: 'The `.describe()` method still exists for compatibility with Zod 3, but `.meta()` is now the recommended approach.',
-        },
-        schema: [],
-    },
-    defaultOptions: [],
-    create(context) {
-        const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods, } = trackZodSchemaImports();
-        return {
-            ImportDeclaration: importDeclarationListener,
-            CallExpression(node) {
-                const zodSchemaMeta = detectZodSchemaRootNode(node);
-                if (!zodSchemaMeta) {
-                    return;
-                }
-                const describe = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === 'describe');
-                if (!describe) {
-                    return;
-                }
-                const { callee, arguments: [describeArg], } = describe.node;
-                context.report({
-                    node,
-                    messageId: 'preferMeta',
-                    fix(fixer) {
-                        return [
-                            fixer.replaceText(callee.property, 'meta'),
-                            fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`),
-                        ];
-                    },
-                });
-            },
-        };
-    },
+const require_create_plugin_rule = require("../utils/create-plugin-rule.cjs");
+//#region src/rules/prefer-meta.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = require("../utils/track-zod-schema-imports.cjs").createZodSchemaImportTrack("all");
+const preferMeta = require_create_plugin_rule.createZodPluginRule({
+	name: "prefer-meta",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce usage of `.meta()` over `.describe()`"
+		},
+		messages: { preferMeta: "The `.describe()` method still exists for compatibility with Zod 3, but `.meta()` is now the recommended approach." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const describe = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "describe");
+				if (!describe) return;
+				const { callee, arguments: [describeArg] } = describe.node;
+				context.report({
+					node,
+					messageId: "preferMeta",
+					fix(fixer) {
+						return [fixer.replaceText(callee.property, "meta"), fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`)];
+					}
+				});
+			}
+		};
+	}
 });
+//#endregion
+exports.preferMeta = preferMeta;

package/dist/rules/prefer-meta.mjs

@@ -0,0 +1,40 @@
+import { createZodPluginRule } from "../utils/create-plugin-rule.mjs";
+import { createZodSchemaImportTrack } from "../utils/track-zod-schema-imports.mjs";
+//#region src/rules/prefer-meta.ts
+const { zodImportAllowedSource, trackZodSchemaImports } = createZodSchemaImportTrack("all");
+const preferMeta = createZodPluginRule({
+	name: "prefer-meta",
+	meta: {
+		type: "suggestion",
+		fixable: "code",
+		docs: {
+			zodImportAllowedSource,
+			description: "Enforce usage of `.meta()` over `.describe()`"
+		},
+		messages: { preferMeta: "The `.describe()` method still exists for compatibility with Zod 3, but `.meta()` is now the recommended approach." },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		const { importDeclarationListener, detectZodSchemaRootNode, collectZodChainMethods } = trackZodSchemaImports();
+		return {
+			ImportDeclaration: importDeclarationListener,
+			CallExpression(node) {
+				const zodSchemaMeta = detectZodSchemaRootNode(node);
+				if (!zodSchemaMeta) return;
+				const describe = collectZodChainMethods(zodSchemaMeta.node).find((it) => it.name === "describe");
+				if (!describe) return;
+				const { callee, arguments: [describeArg] } = describe.node;
+				context.report({
+					node,
+					messageId: "preferMeta",
+					fix(fixer) {
+						return [fixer.replaceText(callee.property, "meta"), fixer.replaceText(describeArg, `{ description: ${context.sourceCode.getText(describeArg)} }`)];
+					}
+				});
+			}
+		};
+	}
+});
+//#endregion
+export { preferMeta };

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

@@ -1,149 +1,117 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preferNamespaceImport = 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");
+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/prefer-namespace-import.ts
 function isGroupFirstImportTypeNamespace(group) {
-    const { hasOnlyTypeImports, nodes: [firstImportNode], } = group;
-    const { specifiers } = firstImportNode;
-    if (specifiers.length === 1 &&
-        specifiers[0].type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-        if (hasOnlyTypeImports) {
-            if (firstImportNode.importKind === 'type') {
-                return true;
-            }
-        }
-        else {
-            return true;
-        }
-    }
-    return false;
+	const { hasOnlyTypeImports, nodes: [firstImportNode] } = group;
+	const { specifiers } = firstImportNode;
+	if (specifiers.length === 1 && specifiers[0].type === _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier) if (hasOnlyTypeImports) {
+		if (firstImportNode.importKind === "type") return true;
+	} else return true;
+	return false;
 }
 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.preferNamespaceImport = (0, create_plugin_rule_js_1.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 (!(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 = isGroupFirstImportTypeNamespace(importGroup);
-                    if (!isFirstImportValid) {
-                        context.report({
-                            node: firstImportNode,
-                            messageId: 'useNamespace',
-                            fix(fixer) {
-                                const importTypeKeyword = hasOnlyTypeImports ? 'type ' : '';
-                                const newImportText = `import ${importTypeKeyword}* as ${namespaceAliasName} 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',
-                                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 preferNamespaceImport = require_create_plugin_rule.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 (!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 (!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
+exports.preferNamespaceImport = preferNamespaceImport;