eslint-plugin-zod 3.5.1 → 3.5.2

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

@@ -1,31 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildZodChainReplacementFix = buildZodChainReplacementFix;
+//#region src/utils/build-zod-chain-replacement-fix.ts
+/**
+* Utility to generate a fixer for replacing a method chain like z.string().uuid() or z.number().int()
+* with z.uuid() or z.int(), preserving any intermediate methods.
+*
+* @param opts Object containing all options for the fixer
+* @returns Fixer replaceTextRange call
+*/
 function buildZodChainReplacementFix(opts) {
-    var _a, _b;
-    const { sourceCode, fixer, methods, fromIndex, toIndex, toMethodName } = opts;
-    const fromNode = (_a = methods[fromIndex]) === null || _a === void 0 ? void 0 : _a.node;
-    const toNode = (_b = methods[toIndex]) === null || _b === void 0 ? void 0 : _b.node;
-    if (!fromNode || !toNode) {
-        return null;
-    }
-    const fromCallee = fromNode.callee;
-    const prefixObj = fromCallee.object;
-    const prefixText = sourceCode.getText(prefixObj);
-    const methodsBetween = methods.slice(fromIndex + 1, toIndex);
-    const betweenSuffixes = methodsBetween.map((m) => {
-        const betweenCallee = m.node.callee;
-        const objText = sourceCode.getText(betweenCallee.object);
-        const fullText = sourceCode.getText(m.node);
-        return fullText.slice(objText.length);
-    });
-    let replacement = `${prefixText}.${toMethodName}(`;
-    if (toNode.arguments.length) {
-        const argsText = toNode.arguments
-            .map((arg) => sourceCode.getText(arg))
-            .join(', ');
-        replacement += argsText;
-    }
-    replacement += `)${betweenSuffixes.join('')}`;
-    return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
+	const { sourceCode, fixer, methods, fromIndex, toIndex, toMethodName } = opts;
+	const fromNode = methods[fromIndex]?.node;
+	const toNode = methods[toIndex]?.node;
+	if (!fromNode || !toNode) return null;
+	const prefixObj = fromNode.callee.object;
+	const prefixText = sourceCode.getText(prefixObj);
+	const betweenSuffixes = methods.slice(fromIndex + 1, toIndex).map((m) => {
+		const betweenCallee = m.node.callee;
+		const objText = sourceCode.getText(betweenCallee.object);
+		return sourceCode.getText(m.node).slice(objText.length);
+	});
+	let replacement = `${prefixText}.${toMethodName}(`;
+	if (toNode.arguments.length) {
+		const argsText = toNode.arguments.map((arg) => sourceCode.getText(arg)).join(", ");
+		replacement += argsText;
+	}
+	replacement += `)${betweenSuffixes.join("")}`;
+	return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
 }
+//#endregion
+exports.buildZodChainReplacementFix = buildZodChainReplacementFix;

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

@@ -0,0 +1,30 @@
+//#region src/utils/build-zod-chain-replacement-fix.ts
+/**
+* Utility to generate a fixer for replacing a method chain like z.string().uuid() or z.number().int()
+* with z.uuid() or z.int(), preserving any intermediate methods.
+*
+* @param opts Object containing all options for the fixer
+* @returns Fixer replaceTextRange call
+*/
+function buildZodChainReplacementFix(opts) {
+	const { sourceCode, fixer, methods, fromIndex, toIndex, toMethodName } = opts;
+	const fromNode = methods[fromIndex]?.node;
+	const toNode = methods[toIndex]?.node;
+	if (!fromNode || !toNode) return null;
+	const prefixObj = fromNode.callee.object;
+	const prefixText = sourceCode.getText(prefixObj);
+	const betweenSuffixes = methods.slice(fromIndex + 1, toIndex).map((m) => {
+		const betweenCallee = m.node.callee;
+		const objText = sourceCode.getText(betweenCallee.object);
+		return sourceCode.getText(m.node).slice(objText.length);
+	});
+	let replacement = `${prefixText}.${toMethodName}(`;
+	if (toNode.arguments.length) {
+		const argsText = toNode.arguments.map((arg) => sourceCode.getText(arg)).join(", ");
+		replacement += argsText;
+	}
+	replacement += `)${betweenSuffixes.join("")}`;
+	return fixer.replaceTextRange([fromNode.range[0], toNode.range[1]], replacement);
+}
+//#endregion
+export { buildZodChainReplacementFix };

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

@@ -1,6 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZodPluginRule = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-const meta_js_1 = require("../meta.cjs");
-exports.createZodPluginRule = utils_1.ESLintUtils.RuleCreator(meta_js_1.getRuleURL);
+require("../_virtual/_rolldown/runtime.cjs");
+const require_meta = require("../meta.cjs");
+//#region src/utils/create-plugin-rule.ts
+const createZodPluginRule = require("@typescript-eslint/utils").ESLintUtils.RuleCreator(require_meta.getRuleURL);
+//#endregion
+exports.createZodPluginRule = createZodPluginRule;

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

@@ -0,0 +1,6 @@
+import { getRuleURL } from "../meta.mjs";
+import { ESLintUtils } from "@typescript-eslint/utils";
+//#region src/utils/create-plugin-rule.ts
+const createZodPluginRule = ESLintUtils.RuleCreator(getRuleURL);
+//#endregion
+export { createZodPluginRule };

package/dist/utils/detect-zod-schema-root-node.cjs

@@ -1,104 +1,102 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectZodSchemaRootNode = detectZodSchemaRootNode;
-const utils_1 = require("@typescript-eslint/utils");
+require("../_virtual/_rolldown/runtime.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/utils/detect-zod-schema-root-node.ts
+/**
+* Helper: extract static property names (Identifier | Literal | simple template literal)
+*/
 function getPropertyName(prop) {
-    if (!prop) {
-        return null;
-    }
-    if (prop.type === utils_1.AST_NODE_TYPES.Identifier) {
-        return prop.name;
-    }
-    if (prop.type === utils_1.AST_NODE_TYPES.Literal) {
-        return prop.value == null ? null : String(prop.value);
-    }
-    if (prop.type === utils_1.AST_NODE_TYPES.TemplateLiteral) {
-        if (prop.expressions.length === 0 && prop.quasis.length === 1) {
-            return prop.quasis[0].value.cooked;
-        }
-        return null;
-    }
-    return null;
+	if (!prop) return null;
+	if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) return prop.name;
+	if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.Literal) return prop.value == null ? null : String(prop.value);
+	if (prop.type === _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral) {
+		if (prop.expressions.length === 0 && prop.quasis.length === 1) return prop.quasis[0].value.cooked;
+		return null;
+	}
+	return null;
 }
+/** Quick check: only process outermost call in a chain */
 function isOutermostCallExpression(node) {
-    const { parent } = node;
-    if (parent.type === utils_1.AST_NODE_TYPES.CallExpression && parent.callee === node) {
-        return false;
-    }
-    if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-        parent.object === node) {
-        return false;
-    }
-    return true;
+	const { parent } = node;
+	if (parent.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression && parent.callee === node) return false;
+	if (parent.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && parent.object === node) return false;
+	return true;
 }
+/**
+* Parse a CallExpression to detect whether it's a zod schema expression (namespace or named).
+* This helper DOES NOT require the call to be outermost.
+*
+* Returns:
+*  { schemaDecl, schemaType, methods, node } if successful
+*  null otherwise
+*/
 function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
-    var _a;
-    let cur = call.callee;
-    const methodsRightToLeft = [];
-    let leftmostIdentifier = null;
-    while (true) {
-        if (cur.type === utils_1.AST_NODE_TYPES.CallExpression) {
-            cur = cur.callee;
-            continue;
-        }
-        if (cur.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-            const name = getPropertyName(cur.property);
-            if (!name) {
-                return null;
-            }
-            methodsRightToLeft.push(name);
-            cur = cur.object;
-            continue;
-        }
-        if (cur.type === utils_1.AST_NODE_TYPES.Identifier) {
-            leftmostIdentifier = cur.name;
-            break;
-        }
-        return null;
-    }
-    const methods = methodsRightToLeft.slice().reverse();
-    if (!leftmostIdentifier) {
-        return null;
-    }
-    if (zodNamespaces.has(leftmostIdentifier)) {
-        const factory = (_a = methods[0]) !== null && _a !== void 0 ? _a : null;
-        if (!factory) {
-            return null;
-        }
-        return {
-            schemaDecl: 'namespace',
-            schemaType: factory,
-            methods,
-            node: call,
-        };
-    }
-    if (zodNamedImports.has(leftmostIdentifier)) {
-        const factory = leftmostIdentifier;
-        return {
-            schemaDecl: 'named',
-            schemaType: factory,
-            methods,
-            node: call,
-        };
-    }
-    return null;
+	let cur = call.callee;
+	const methodsRightToLeft = [];
+	let leftmostIdentifier = null;
+	while (true) {
+		if (cur.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+			cur = cur.callee;
+			continue;
+		}
+		if (cur.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression) {
+			const name = getPropertyName(cur.property);
+			if (!name) return null;
+			methodsRightToLeft.push(name);
+			cur = cur.object;
+			continue;
+		}
+		if (cur.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+			leftmostIdentifier = cur.name;
+			break;
+		}
+		return null;
+	}
+	const methods = methodsRightToLeft.slice().reverse();
+	if (!leftmostIdentifier) return null;
+	if (zodNamespaces.has(leftmostIdentifier)) {
+		const factory = methods[0] ?? null;
+		if (!factory) return null;
+		return {
+			schemaDecl: "namespace",
+			schemaType: factory,
+			methods,
+			node: call
+		};
+	}
+	if (zodNamedImports.has(leftmostIdentifier)) return {
+		schemaDecl: "named",
+		schemaType: leftmostIdentifier,
+		methods,
+		node: call
+	};
+	return null;
 }
+/** Examine an expression (argument) for zod schema CallExpressions.
+* Supports:
+*  - direct CallExpression (string(), z.string(), etc)
+*  - ArrayExpression where elements may be CallExpressions (e.g. union([a(), b()]))
+*
+* Returns list of parsed inner schema infos (may be empty).
+*/
+/**
+* The final exported function.
+*
+* node: CallExpression node given by ESLint visitor
+* zodNamespaces: e.g. new Set(['z'])
+* zodNamedImports: e.g. new Set(['number','string','array',...])
+*/
 function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
-    if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
-        return null;
-    }
-    const call = node;
-    if (!isOutermostCallExpression(call)) {
-        return null;
-    }
-    const outer = parseZodCallExpression(call, zodNamespaces, zodNamedImports);
-    if (!outer) {
-        return null;
-    }
-    return {
-        schemaDecl: outer.schemaDecl,
-        schemaType: outer.schemaType,
-        methods: outer.methods,
-        node: call,
-    };
+	if (node.type !== _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) return null;
+	const call = node;
+	if (!isOutermostCallExpression(call)) return null;
+	const outer = parseZodCallExpression(call, zodNamespaces, zodNamedImports);
+	if (!outer) return null;
+	return {
+		schemaDecl: outer.schemaDecl,
+		schemaType: outer.schemaType,
+		methods: outer.methods,
+		node: call
+	};
 }
+//#endregion
+exports.detectZodSchemaRootNode = detectZodSchemaRootNode;

package/dist/utils/detect-zod-schema-root-node.mjs

@@ -0,0 +1,101 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+//#region src/utils/detect-zod-schema-root-node.ts
+/**
+* Helper: extract static property names (Identifier | Literal | simple template literal)
+*/
+function getPropertyName(prop) {
+	if (!prop) return null;
+	if (prop.type === AST_NODE_TYPES.Identifier) return prop.name;
+	if (prop.type === AST_NODE_TYPES.Literal) return prop.value == null ? null : String(prop.value);
+	if (prop.type === AST_NODE_TYPES.TemplateLiteral) {
+		if (prop.expressions.length === 0 && prop.quasis.length === 1) return prop.quasis[0].value.cooked;
+		return null;
+	}
+	return null;
+}
+/** Quick check: only process outermost call in a chain */
+function isOutermostCallExpression(node) {
+	const { parent } = node;
+	if (parent.type === AST_NODE_TYPES.CallExpression && parent.callee === node) return false;
+	if (parent.type === AST_NODE_TYPES.MemberExpression && parent.object === node) return false;
+	return true;
+}
+/**
+* Parse a CallExpression to detect whether it's a zod schema expression (namespace or named).
+* This helper DOES NOT require the call to be outermost.
+*
+* Returns:
+*  { schemaDecl, schemaType, methods, node } if successful
+*  null otherwise
+*/
+function parseZodCallExpression(call, zodNamespaces, zodNamedImports) {
+	let cur = call.callee;
+	const methodsRightToLeft = [];
+	let leftmostIdentifier = null;
+	while (true) {
+		if (cur.type === AST_NODE_TYPES.CallExpression) {
+			cur = cur.callee;
+			continue;
+		}
+		if (cur.type === AST_NODE_TYPES.MemberExpression) {
+			const name = getPropertyName(cur.property);
+			if (!name) return null;
+			methodsRightToLeft.push(name);
+			cur = cur.object;
+			continue;
+		}
+		if (cur.type === AST_NODE_TYPES.Identifier) {
+			leftmostIdentifier = cur.name;
+			break;
+		}
+		return null;
+	}
+	const methods = methodsRightToLeft.slice().reverse();
+	if (!leftmostIdentifier) return null;
+	if (zodNamespaces.has(leftmostIdentifier)) {
+		const factory = methods[0] ?? null;
+		if (!factory) return null;
+		return {
+			schemaDecl: "namespace",
+			schemaType: factory,
+			methods,
+			node: call
+		};
+	}
+	if (zodNamedImports.has(leftmostIdentifier)) return {
+		schemaDecl: "named",
+		schemaType: leftmostIdentifier,
+		methods,
+		node: call
+	};
+	return null;
+}
+/** Examine an expression (argument) for zod schema CallExpressions.
+* Supports:
+*  - direct CallExpression (string(), z.string(), etc)
+*  - ArrayExpression where elements may be CallExpressions (e.g. union([a(), b()]))
+*
+* Returns list of parsed inner schema infos (may be empty).
+*/
+/**
+* The final exported function.
+*
+* node: CallExpression node given by ESLint visitor
+* zodNamespaces: e.g. new Set(['z'])
+* zodNamedImports: e.g. new Set(['number','string','array',...])
+*/
+function detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports) {
+	if (node.type !== AST_NODE_TYPES.CallExpression) return null;
+	const call = node;
+	if (!isOutermostCallExpression(call)) return null;
+	const outer = parseZodCallExpression(call, zodNamespaces, zodNamedImports);
+	if (!outer) return null;
+	return {
+		schemaDecl: outer.schemaDecl,
+		schemaType: outer.schemaType,
+		methods: outer.methods,
+		node: call
+	};
+}
+//#endregion
+export { detectZodSchemaRootNode };

package/dist/utils/is-zod-import-source.cjs

@@ -1,21 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZOD_IMPORT_SOURCES = void 0;
-exports.isZodImportSource = isZodImportSource;
-exports.ZOD_IMPORT_SOURCES = [
-    'zod',
-    'zod/mini',
-    'zod/v4',
-    'zod/v4-mini',
-    'zod/v3',
+//#region src/utils/is-zod-import-source.ts
+const ZOD_IMPORT_SOURCES = [
+	"zod",
+	"zod/mini",
+	"zod/v4",
+	"zod/v4-mini",
+	"zod/v3"
 ];
 function isZodImportSource(source, allowedSource) {
-    const allowedSources = [];
-    if (allowedSource === 'all' || allowedSource === 'zod') {
-        allowedSources.push('zod', 'zod/v4', 'zod/v3');
-    }
-    if (allowedSource === 'all' || allowedSource === 'zod-mini') {
-        allowedSources.push('zod/mini', 'zod/v4-mini');
-    }
-    return allowedSources.includes(source);
+	const allowedSources = [];
+	if (allowedSource === "all" || allowedSource === "zod") allowedSources.push("zod", "zod/v4", "zod/v3");
+	if (allowedSource === "all" || allowedSource === "zod-mini") allowedSources.push("zod/mini", "zod/v4-mini");
+	return allowedSources.includes(source);
 }
+//#endregion
+exports.ZOD_IMPORT_SOURCES = ZOD_IMPORT_SOURCES;
+exports.isZodImportSource = isZodImportSource;

package/dist/utils/is-zod-import-source.mjs

@@ -0,0 +1,16 @@
+//#region src/utils/is-zod-import-source.ts
+const ZOD_IMPORT_SOURCES = [
+	"zod",
+	"zod/mini",
+	"zod/v4",
+	"zod/v4-mini",
+	"zod/v3"
+];
+function isZodImportSource(source, allowedSource) {
+	const allowedSources = [];
+	if (allowedSource === "all" || allowedSource === "zod") allowedSources.push("zod", "zod/v4", "zod/v3");
+	if (allowedSource === "all" || allowedSource === "zod-mini") allowedSources.push("zod/mini", "zod/v4-mini");
+	return allowedSources.includes(source);
+}
+//#endregion
+export { ZOD_IMPORT_SOURCES, isZodImportSource };

package/dist/utils/track-zod-schema-imports.cjs

@@ -1,67 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZodSchemaImportTrack = createZodSchemaImportTrack;
-const utils_1 = require("@typescript-eslint/utils");
-const detect_zod_schema_root_node_js_1 = require("./detect-zod-schema-root-node.cjs");
-const is_zod_import_source_js_1 = require("./is-zod-import-source.cjs");
+require("../_virtual/_rolldown/runtime.cjs");
+const require_detect_zod_schema_root_node = require("./detect-zod-schema-root-node.cjs");
+const require_is_zod_import_source = require("./is-zod-import-source.cjs");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+//#region src/utils/track-zod-schema-imports.ts
+/**
+* Function to create helpers that allow to manage default, namespace and named `zod`
+* imports without too much hassle.
+*/
 function trackZodSchemaImports(importAllowedSource) {
-    const zodNamespaces = new Set();
-    const zodNamedImports = new Set();
-    function collectZodChainMethods(node) {
-        const methods = [];
-        let current = node;
-        while (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
-            const { callee } = current;
-            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                methods.unshift({
-                    name: callee.property.name,
-                    node: current,
-                });
-                current = callee.object;
-                continue;
-            }
-            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                methods.unshift({
-                    name: callee.name,
-                    node: current,
-                });
-                break;
-            }
-            break;
-        }
-        return methods;
-    }
-    const result = {
-        importDeclarationListener(node) {
-            if (!(0, is_zod_import_source_js_1.isZodImportSource)(node.source.value, importAllowedSource)) {
-                return;
-            }
-            for (const spec of node.specifiers) {
-                switch (spec.type) {
-                    case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier:
-                    case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier:
-                        zodNamespaces.add(spec.local.name);
-                        break;
-                    case utils_1.AST_NODE_TYPES.ImportSpecifier:
-                        if ('name' in spec.imported && spec.imported.name === 'z') {
-                            zodNamespaces.add(spec.local.name);
-                        }
-                        else {
-                            zodNamedImports.add(spec.local.name);
-                        }
-                        break;
-                }
-            }
-        },
-        detectZodSchemaRootNode: (node) => (0, detect_zod_schema_root_node_js_1.detectZodSchemaRootNode)(node, zodNamespaces, zodNamedImports),
-        collectZodChainMethods,
-    };
-    return result;
+	const zodNamespaces = /* @__PURE__ */ new Set();
+	const zodNamedImports = /* @__PURE__ */ new Set();
+	function collectZodChainMethods(node) {
+		const methods = [];
+		let current = node;
+		while (current.type === _typescript_eslint_utils.AST_NODE_TYPES.CallExpression) {
+			const { callee } = current;
+			if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.MemberExpression && callee.property.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+				methods.unshift({
+					name: callee.property.name,
+					node: current
+				});
+				current = callee.object;
+				continue;
+			}
+			if (callee.type === _typescript_eslint_utils.AST_NODE_TYPES.Identifier) {
+				methods.unshift({
+					name: callee.name,
+					node: current
+				});
+				break;
+			}
+			break;
+		}
+		return methods;
+	}
+	return {
+		importDeclarationListener(node) {
+			if (!require_is_zod_import_source.isZodImportSource(node.source.value, importAllowedSource)) return;
+			for (const spec of node.specifiers) switch (spec.type) {
+				case _typescript_eslint_utils.AST_NODE_TYPES.ImportDefaultSpecifier:
+				case _typescript_eslint_utils.AST_NODE_TYPES.ImportNamespaceSpecifier:
+					zodNamespaces.add(spec.local.name);
+					break;
+				case _typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier:
+					if ("name" in spec.imported && spec.imported.name === "z") zodNamespaces.add(spec.local.name);
+					else zodNamedImports.add(spec.local.name);
+					break;
+			}
+		},
+		detectZodSchemaRootNode: (node) => require_detect_zod_schema_root_node.detectZodSchemaRootNode(node, zodNamespaces, zodNamedImports),
+		collectZodChainMethods
+	};
 }
+/**
+* Wrapper to avoid duplication of importAllowedSource across rule code
+*/
 function createZodSchemaImportTrack(zodImportAllowedSource) {
-    return {
-        zodImportAllowedSource,
-        trackZodSchemaImports: () => trackZodSchemaImports(zodImportAllowedSource),
-    };
+	return {
+		zodImportAllowedSource,
+		trackZodSchemaImports: () => trackZodSchemaImports(zodImportAllowedSource)
+	};
 }
+//#endregion
+exports.createZodSchemaImportTrack = createZodSchemaImportTrack;