@politty/zod 0.0.0

package/dist/runner-FvUwOHyE.js

@@ -0,0 +1,3 @@
+import { n as runMain, t as runCommand } from "./runner-D72I7wvK.js";
+
+export { runCommand };

package/dist/schema-extractor-DMSozq40.js

@@ -0,0 +1,250 @@
+import { a as getValidatorAdapter, n as resolveFieldMeta } from "./field-meta-DMy5BcRr.js";
+
+//#region ../core/src/adapter/internal-args.ts
+/** Runtime brand distinguishing internal descriptors from library schemas. */
+const INTERNAL_ARGS_BRAND = "__polittyInternalArgs";
+/**
+* Field builders for {@link internalArgs}. Only the shapes internal
+* commands actually need; extend deliberately, not speculatively.
+*/
+const internalField = {
+	/** Required string */
+	string(meta) {
+		return {
+			kind: "string",
+			optional: false,
+			meta
+		};
+	},
+	/** Optional string (undefined when omitted) */
+	optionalString(meta) {
+		return {
+			kind: "string",
+			optional: true,
+			meta
+		};
+	},
+	/** Boolean flag defaulting to false */
+	boolean(meta) {
+		return {
+			kind: "boolean",
+			optional: false,
+			defaultValue: false,
+			meta
+		};
+	},
+	/** Required enum */
+	enum(values, meta) {
+		return {
+			kind: "enum",
+			enumValues: values,
+			optional: false,
+			meta
+		};
+	},
+	/** Optional enum (undefined when omitted) */
+	optionalEnum(values, meta) {
+		return {
+			kind: "enum",
+			enumValues: values,
+			optional: true,
+			meta
+		};
+	},
+	/** String array defaulting to [] */
+	stringArray(meta) {
+		return {
+			kind: "string-array",
+			optional: false,
+			defaultValue: [],
+			meta
+		};
+	},
+	/** Optional string array (undefined when omitted) */
+	optionalStringArray(meta) {
+		return {
+			kind: "string-array",
+			optional: true,
+			meta
+		};
+	}
+};
+/**
+* Build an internal args schema from field descriptors.
+*/
+function internalArgs(fields, options = {}) {
+	return {
+		[INTERNAL_ARGS_BRAND]: true,
+		fields,
+		unknownKeys: options.unknownKeys ?? "strip"
+	};
+}
+/**
+* Runtime check for the internal descriptor brand. The extract/validate
+* facades call this before falling back to the schema-library adapter.
+*/
+function isInternalArgsSchema(schema) {
+	return typeof schema === "object" && schema !== null && schema[INTERNAL_ARGS_BRAND] === true;
+}
+const FIELD_TYPE = {
+	string: "string",
+	boolean: "boolean",
+	enum: "string",
+	"string-array": "array"
+};
+const extractCache = /* @__PURE__ */ new WeakMap();
+/**
+* Extract neutral field metadata from an internal args schema.
+*/
+function extractInternalFields(schema) {
+	const cached = extractCache.get(schema);
+	if (cached) return cached;
+	const result = {
+		fields: Object.entries(schema.fields).map(([name, spec]) => resolveFieldMeta(name, {
+			argMeta: spec.meta,
+			description: void 0,
+			required: !spec.optional && spec.defaultValue === void 0,
+			defaultValue: spec.defaultValue,
+			type: FIELD_TYPE[spec.kind],
+			enumValues: spec.enumValues ? [...spec.enumValues] : void 0,
+			schema: spec
+		})),
+		schema,
+		schemaType: "object",
+		unknownKeysMode: schema.unknownKeys
+	};
+	extractCache.set(schema, result);
+	return result;
+}
+function expectedLabel(spec) {
+	switch (spec.kind) {
+		case "enum": return `one of ${(spec.enumValues ?? []).map((v) => JSON.stringify(v)).join(" | ")}`;
+		case "string-array": return "array";
+		default: return spec.kind;
+	}
+}
+function receivedLabel(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	return typeof value;
+}
+function typeError(name, spec, received) {
+	return {
+		path: [name],
+		message: `Invalid input: expected ${expectedLabel(spec)}, received ${receivedLabel(received)}`,
+		code: "invalid_type",
+		received,
+		expected: expectedLabel(spec)
+	};
+}
+function checkValue(name, spec, value) {
+	switch (spec.kind) {
+		case "string": return typeof value === "string" ? null : typeError(name, spec, value);
+		case "boolean": return typeof value === "boolean" ? null : typeError(name, spec, value);
+		case "enum":
+			if (typeof value !== "string" || !(spec.enumValues ?? []).includes(value)) return {
+				path: [name],
+				message: `Invalid option: expected ${expectedLabel(spec)}`,
+				code: "invalid_value",
+				received: value,
+				expected: expectedLabel(spec)
+			};
+			return null;
+		case "string-array":
+			if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) return typeError(name, spec, value);
+			return null;
+	}
+}
+/**
+* Validate raw parsed args against an internal args schema. Mirrors the
+* schema-library semantics the parser relies on: defaults fill missing
+* values, optional fields stay absent, and unknown keys follow the
+* descriptor's `unknownKeys` mode (strip by default, like z.object()).
+*/
+function validateInternalArgs(rawArgs, schema) {
+	const errors = [];
+	const data = {};
+	for (const [name, spec] of Object.entries(schema.fields)) {
+		const value = rawArgs[name];
+		if (value === void 0) {
+			if (spec.defaultValue !== void 0) data[name] = Array.isArray(spec.defaultValue) ? [...spec.defaultValue] : spec.defaultValue;
+			else if (!spec.optional) errors.push(typeError(name, spec, void 0));
+			continue;
+		}
+		const error = checkValue(name, spec, value);
+		if (error) {
+			errors.push(error);
+			continue;
+		}
+		data[name] = value;
+	}
+	const knownNames = new Set(Object.keys(schema.fields));
+	const unknownKeys = Object.keys(rawArgs).filter((key) => !knownNames.has(key));
+	if (unknownKeys.length > 0) {
+		if (schema.unknownKeys === "strict") errors.push({
+			path: [],
+			message: `Unrecognized key${unknownKeys.length > 1 ? "s" : ""}: ${unknownKeys.map((k) => JSON.stringify(k)).join(", ")}`,
+			code: "unrecognized_keys"
+		});
+		else if (schema.unknownKeys === "passthrough") for (const key of unknownKeys) Object.defineProperty(data, key, {
+			value: rawArgs[key],
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+	}
+	if (errors.length > 0) return {
+		success: false,
+		errors
+	};
+	return {
+		success: true,
+		data
+	};
+}
+
+//#endregion
+//#region ../core/src/core/schema-extractor.ts
+/**
+* Schema extraction facade.
+*
+* The neutral field-metadata shapes and naming helpers live in
+* `adapter/field-meta.ts`; the schema-library-specific introspection lives
+* in the registered validator adapter (e.g. `@politty/zod`). This module
+* keeps the historical import surface (`extractFields`, `toCamelCase`, ...)
+* stable for the rest of the codebase and for the package's public
+* exports, and routes each schema to the implementation that understands
+* it.
+*/
+/**
+* Detect the unknown-keys handling mode of an args schema. Works for any
+* schema politty itself attaches to a command (including internal
+* descriptor-based commands), not just user-provided library schemas.
+*/
+function getUnknownKeysMode(schema) {
+	if (isInternalArgsSchema(schema)) return schema.unknownKeys;
+	return getValidatorAdapter().getUnknownKeysMode(schema);
+}
+/**
+* Extract all fields from a schema
+*
+* @param schema - The args schema (ZodObject, ZodDiscriminatedUnion, etc.)
+* @returns Extracted field information
+*/
+function extractFields(schema) {
+	if (isInternalArgsSchema(schema)) return extractInternalFields(schema);
+	return getValidatorAdapter().extractFields(schema);
+}
+/**
+* Get extracted fields from a command
+*
+* @param command - The command to extract fields from
+* @returns Extracted field information, or null if command has no args schema
+*/
+function getExtractedFields(command) {
+	if (!command.args) return null;
+	return extractFields(command.args);
+}
+
+//#endregion
+export { internalField as a, internalArgs as i, getExtractedFields as n, isInternalArgsSchema as o, getUnknownKeysMode as r, validateInternalArgs as s, extractFields as t };