@politty/zod 0.1.2 → 0.2.1

package/dist/register-DdcsbNwM.js

@@ -1,440 +0,0 @@
-import { n as resolveFieldMeta, o as registerValidatorAdapter } from "./field-meta-CO38jOvl.js";
-
-//#region ../core/src/core/arg-registry.ts
-/**
-* Custom registry for politty argument metadata, keyed by schema identity.
-* This avoids polluting Zod's GlobalMeta, and — unlike `z.registry()` — is
-* validator-neutral: any schema object (zod, valibot, internal descriptors)
-* can carry arg metadata without politty importing the schema library.
-*/
-const argRegistry = /* @__PURE__ */ new WeakMap();
-function arg(schema, meta) {
-	if (meta) argRegistry.set(schema, meta);
-	return schema;
-}
-/**
-* Get metadata for a schema from the registry
-*
-* @param schema - The schema object used as the registry key
-* @returns The metadata if registered, undefined otherwise
-*/
-function getArgMeta$1(schema) {
-	return argRegistry.get(schema);
-}
-
-//#endregion
-//#region src/adapter.ts
-/**
-* Zod validator adapter: implements politty's neutral `ValidatorAdapter`
-* contract against zod v4's schema representation.
-*
-* All introspection here is structural (`_def` / `.def` access, method
-* calls on the schema object) — this module never imports zod at runtime,
-* so it stays out of the user's startup path until a zod schema actually
-* flows through it.
-*/
-/**
-* Get ArgMeta from both the custom registry and Zod's _def
-* Priority: custom registry > _def.argMeta
-*/
-function getArgMeta(schema) {
-	const fromRegistry = getArgMeta$1(schema);
-	if (fromRegistry) return fromRegistry;
-	if (typeof schema.meta === "function") {
-		const meta = schema.meta();
-		if (meta && typeof meta === "object") return meta;
-	}
-	const def = schema._def;
-	if (def?.argMeta) return def.argMeta;
-	if (def?.meta) return def.meta;
-}
-/**
-* Get the type name from a zod schema (v4 compatible)
-*/
-function getTypeName(schema) {
-	const s = schema;
-	return s.def?.type ?? s._def?.type ?? s.type;
-}
-/**
-* Detect unknown keys handling mode from a Zod object schema
-*
-* In Zod v4:
-* - Default (strip): _def.catchall is undefined
-* - strict: _def.catchall is ZodNever (type = "never")
-* - passthrough: _def.catchall is ZodUnknown (type = "unknown")
-*/
-function getUnknownKeysMode(schema) {
-	const s = unwrapSchema(schema);
-	const catchall = (s.def ?? s._def)?.catchall;
-	if (!catchall) return "strip";
-	const catchallType = getTypeName(catchall);
-	if (catchallType === "never") return "strict";
-	if (catchallType === "unknown" || catchallType === "any") return "passthrough";
-	return "strip";
-}
-/**
-* Get the inner schema, unwrapping optional, nullable, default, etc.
-*/
-function unwrapSchema(schema) {
-	const typeName = getTypeName(schema);
-	const s = schema;
-	const def = s.def ?? s._def;
-	if (typeName === "optional" || typeName === "nullable" || typeName === "default") {
-		const innerSchema = def?.innerType;
-		if (innerSchema) return unwrapSchema(innerSchema);
-	}
-	if (typeName === "pipe") {
-		const innerSchema = def?.in ?? def?.schema;
-		if (innerSchema) return unwrapSchema(innerSchema);
-	}
-	return schema;
-}
-/**
-* Detect the base type of a schema
-*/
-function detectType(schema) {
-	switch (getTypeName(unwrapSchema(schema))) {
-		case "string":
-		case "enum": return "string";
-		case "number":
-		case "int": return "number";
-		case "boolean": return "boolean";
-		case "array": return "array";
-		default: return "unknown";
-	}
-}
-/**
-* Extract enum values from a schema if it's an enum type
-*
-* @param schema - The Zod schema to extract enum values from
-* @returns Array of enum values if schema is an enum, undefined otherwise
-*/
-function extractEnumValues(schema) {
-	const innerSchema = unwrapSchema(schema);
-	const typeName = getTypeName(innerSchema);
-	const s = innerSchema;
-	const def = s.def ?? s._def;
-	if (typeName === "enum") {
-		const entries = def?.entries;
-		if (entries && typeof entries === "object") return Object.values(entries);
-		const values = def?.values;
-		if (Array.isArray(values)) return values;
-		const options = s.options;
-		if (Array.isArray(options)) return options;
-	}
-	if (typeName === "array") {
-		const element = def?.element;
-		if (element) return extractEnumValues(element);
-	}
-	if (typeName === "union") {
-		const options = def?.options;
-		if (Array.isArray(options)) {
-			const literalValues = [];
-			for (const option of options) if (getTypeName(option) === "literal") {
-				const optionDef = option.def ?? option._def;
-				const value = optionDef?.value;
-				const values = optionDef?.values;
-				const literalValue = value ?? values?.[0];
-				if (typeof literalValue === "string") literalValues.push(literalValue);
-			}
-			if (literalValues.length === options.length && literalValues.length > 0) return literalValues;
-		}
-	}
-}
-/**
-* Check if a schema is required (not optional or has default)
-*
-* Note: We only check isOptional(), not isNullable(), because CLI arguments
-* are either present (string value) or absent (undefined), never null.
-* Also, some coerce types incorrectly report isNullable()=true.
-*/
-function isRequired(schema) {
-	return !schema.isOptional();
-}
-/**
-* Extract default value from schema if present
-*/
-function extractDefaultValue(schema) {
-	const typeName = getTypeName(schema);
-	const s = schema;
-	const def = s.def ?? s._def;
-	if (typeName === "default") {
-		const defaultValue = def?.defaultValue;
-		if (typeof defaultValue === "function") return defaultValue();
-		return defaultValue;
-	}
-	if (typeName === "optional" || typeName === "nullable") {
-		const innerSchema = def?.innerType;
-		if (innerSchema) return extractDefaultValue(innerSchema);
-	}
-}
-/**
-* Extract description from schema
-*/
-function extractDescription(schema) {
-	if (schema.description) return schema.description;
-	const typeName = getTypeName(schema);
-	const s = schema;
-	const def = s.def ?? s._def;
-	if (typeName === "optional" || typeName === "nullable" || typeName === "default") {
-		const innerSchema = def?.innerType;
-		if (innerSchema) return extractDescription(innerSchema);
-	}
-}
-/**
-* Resolve field metadata from a zod field schema. The zod-specific
-* introspection happens here; the shared alias/negation policy lives in
-* `resolveFieldMeta` (adapter/field-meta.ts).
-*/
-function resolveZodFieldMeta(name, schema) {
-	const argMeta = getArgMeta(schema) ?? getArgMeta(unwrapSchema(schema));
-	return resolveFieldMeta(name, {
-		argMeta,
-		description: extractDescription(schema),
-		required: isRequired(schema),
-		defaultValue: extractDefaultValue(schema),
-		type: detectType(schema),
-		enumValues: extractEnumValues(schema),
-		schema
-	});
-}
-/**
-* Get shape from a ZodObject
-*/
-function getObjectShape(schema) {
-	const s = schema;
-	return (s.def ?? s._def)?.shape ?? s.shape ?? {};
-}
-/**
-* Extract fields from a ZodObject
-*/
-function extractFromObject(schema) {
-	const shape = getObjectShape(schema);
-	return Object.entries(shape).map(([name, fieldSchema]) => resolveZodFieldMeta(name, fieldSchema));
-}
-/**
-* Extract fields from a discriminated union
-*/
-function extractFromDiscriminatedUnion(schema) {
-	const s = schema;
-	const def = s.def ?? s._def;
-	const discriminator = def?.discriminator ?? "";
-	const options = def?.options ?? [];
-	const allFieldsMap = /* @__PURE__ */ new Map();
-	const variants = [];
-	for (const option of options) {
-		const shape = getObjectShape(option);
-		const variantFields = [];
-		let discriminatorValue = "";
-		const discriminatorSchema = shape[discriminator];
-		if (discriminatorSchema) {
-			const typeName = getTypeName(discriminatorSchema);
-			if (typeName === "literal") {
-				const litDef = discriminatorSchema.def ?? discriminatorSchema._def;
-				const value = litDef?.value;
-				const values = litDef?.values;
-				discriminatorValue = String(value ?? values?.[0] ?? "");
-			} else if (typeName === "enum") {
-				const enumValues = extractEnumValues(discriminatorSchema);
-				if (enumValues && enumValues.length === 1) discriminatorValue = enumValues[0];
-			}
-		}
-		for (const [name, fieldSchema] of Object.entries(shape)) {
-			const fieldMeta = resolveZodFieldMeta(name, fieldSchema);
-			variantFields.push(fieldMeta);
-			if (!allFieldsMap.has(name)) allFieldsMap.set(name, fieldMeta);
-		}
-		const variantDescription = extractDescription(option);
-		variants.push({
-			discriminatorValue,
-			fields: variantFields,
-			...variantDescription ? { description: variantDescription } : {}
-		});
-	}
-	const description = extractDescription(schema);
-	return {
-		fields: Array.from(allFieldsMap.values()),
-		schema,
-		schemaType: "discriminatedUnion",
-		unknownKeysMode: getUnknownKeysMode(schema),
-		discriminator,
-		variants,
-		...description ? { description } : {}
-	};
-}
-/**
-* Extract fields from a union-like schema (union or xor)
-*/
-function extractFromUnionLike(schema, schemaType) {
-	const s = schema;
-	const options = (s.def ?? s._def)?.options ?? [];
-	const allFieldsMap = /* @__PURE__ */ new Map();
-	const unionOptions = [];
-	for (const option of options) {
-		const extracted = extractZodFields(option);
-		unionOptions.push(extracted);
-		for (const field of extracted.fields) if (!allFieldsMap.has(field.name)) allFieldsMap.set(field.name, field);
-	}
-	const description = extractDescription(schema);
-	return {
-		fields: Array.from(allFieldsMap.values()),
-		schema,
-		schemaType,
-		unknownKeysMode: getUnknownKeysMode(schema),
-		unionOptions,
-		...description ? { description } : {}
-	};
-}
-/**
-* Extract fields from an intersection
-*/
-function extractFromIntersection(schema) {
-	const s = schema;
-	const def = s.def ?? s._def;
-	const left = def?.left;
-	const right = def?.right;
-	const allFieldsMap = /* @__PURE__ */ new Map();
-	const extractSubFields = (subSchema) => {
-		if (!subSchema) return;
-		const extracted = extractZodFields(subSchema);
-		for (const field of extracted.fields) if (!allFieldsMap.has(field.name)) allFieldsMap.set(field.name, field);
-	};
-	extractSubFields(left);
-	extractSubFields(right);
-	const description = extractDescription(schema);
-	return {
-		fields: Array.from(allFieldsMap.values()),
-		schema,
-		schemaType: "intersection",
-		unknownKeysMode: getUnknownKeysMode(schema),
-		...description ? { description } : {}
-	};
-}
-/**
-* Cache for extractZodFields results to avoid redundant schema extraction
-*/
-const extractFieldsCache = /* @__PURE__ */ new WeakMap();
-/**
-* Extract all fields from a zod args schema
-* (ZodObject, ZodDiscriminatedUnion, etc.)
-*/
-function extractZodFields(schema) {
-	const cached = extractFieldsCache.get(schema);
-	if (cached) return cached;
-	const zodSchema = schema;
-	let result;
-	const typeName = getTypeName(zodSchema);
-	const s = zodSchema;
-	const def = s.def ?? s._def;
-	switch (typeName) {
-		case "object": {
-			const description = extractDescription(zodSchema);
-			result = {
-				fields: extractFromObject(zodSchema),
-				schema,
-				schemaType: "object",
-				unknownKeysMode: getUnknownKeysMode(zodSchema),
-				...description ? { description } : {}
-			};
-			break;
-		}
-		case "union":
-			if (def?.discriminator) result = extractFromDiscriminatedUnion(zodSchema);
-			else result = extractFromUnionLike(zodSchema, "union");
-			break;
-		case "xor":
-			result = extractFromUnionLike(zodSchema, "xor");
-			break;
-		case "intersection":
-			result = extractFromIntersection(zodSchema);
-			break;
-		case "optional":
-		case "nullable":
-		case "default":
-		case "pipe": {
-			const inner = def?.innerType ?? def?.in ?? def?.schema;
-			if (inner) {
-				const innerResult = extractZodFields(inner);
-				const wrapperDescription = extractDescription(zodSchema);
-				result = {
-					...innerResult,
-					schema,
-					...wrapperDescription ? { description: wrapperDescription } : {}
-				};
-				break;
-			}
-			const wrapperDescription = extractDescription(zodSchema);
-			result = {
-				fields: [],
-				schema,
-				schemaType: "object",
-				unknownKeysMode: getUnknownKeysMode(zodSchema),
-				...wrapperDescription ? { description: wrapperDescription } : {}
-			};
-			break;
-		}
-		default: {
-			const description = extractDescription(zodSchema);
-			result = {
-				fields: [],
-				schema,
-				schemaType: "object",
-				unknownKeysMode: getUnknownKeysMode(zodSchema),
-				...description ? { description } : {}
-			};
-			break;
-		}
-	}
-	extractFieldsCache.set(schema, result);
-	return result;
-}
-/**
-* Convert ZodError to ValidationError array (zod v4 compatible)
-*/
-function formatZodErrors(error) {
-	return error.issues.map((issue) => ({
-		path: issue.path.map(String),
-		message: issue.message,
-		code: issue.code,
-		received: "received" in issue ? issue.received : void 0,
-		expected: "expected" in issue ? String(issue.expected) : void 0
-	}));
-}
-/**
-* Validate raw arguments against a zod schema
-*/
-function validateZodArgs(rawArgs, schema) {
-	const result = schema.safeParse(rawArgs);
-	if (result.success) return {
-		success: true,
-		data: result.data
-	};
-	return {
-		success: false,
-		errors: formatZodErrors(result.error)
-	};
-}
-/**
-* The zod validator adapter.
-*/
-const zodAdapter = {
-	vendor: "zod",
-	extractFields: extractZodFields,
-	resolveFieldMeta: (name, fieldSchema) => resolveZodFieldMeta(name, fieldSchema),
-	getUnknownKeysMode: (schema) => getUnknownKeysMode(schema),
-	validate: validateZodArgs
-};
-
-//#endregion
-//#region src/register.ts
-/**
-* Import-time side effect: register the zod adapter with `@politty/core`.
-*
-* Every entry module of this package imports this file first, so any code
-* path a user can reach has the adapter installed before core touches a
-* schema. Registration is idempotent.
-*/
-registerValidatorAdapter(zodAdapter);
-
-//#endregion
-export { arg as t };