@politty/zod 0.1.2 → 0.2.1

package/dist/runner-Cs-Mz9JN.js

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

package/dist/schema-extractor-CVNDs07l.js

@@ -1,250 +0,0 @@
-import { a as getValidatorAdapter, n as resolveFieldMeta } from "./field-meta-CO38jOvl.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 };

package/dist/src-D4QGGgW1.js

@@ -1,6 +0,0 @@
-import "./cli-main-CAa5KwCo.js";
-import "./runner-Bz3arOqh.js";
-import "./logger-i_bb-Jhc.js";
-import "./completion-Ot2qpNNw.js";
-
-export {  };

package/dist/src-DhQVU2hG.js

@@ -1,12 +0,0 @@
-import { i as toKebabCase, r as toCamelCase } from "./field-meta-CO38jOvl.js";
-import { t as arg } from "./register-DdcsbNwM.js";
-import { r as getUnknownKeysMode, t as extractFields } from "./schema-extractor-CVNDs07l.js";
-import { n as createCompileCacheShimGenerator, t as runPolittyCli } from "./cli-main-CAa5KwCo.js";
-import { n as defineCommand, t as createDefineCommand } from "./command-k-4yAz4J.js";
-import { C as ReservedFieldNameError, E as renderMarkdown, S as ReservedAliasError, T as renderInline, _ as DuplicateAliasError, a as parseArgv, b as FieldTypeConflictError, c as validateCommand, d as validateDuplicateFields, f as validateDuplicateNegations, g as CaseVariantCollisionError, h as validateReservedFieldNames, i as formatValidationErrors, l as validateCrossSchemaCollisions, m as validateReservedAliases, n as runMain, o as formatCommandValidationErrors, p as validatePositionalConfig, r as createDualCaseProxy, s as validateCaseVariantCollisions, t as runCommand, u as validateDuplicateAliases, v as DuplicateFieldError, w as generateHelp, x as PositionalConfigError, y as DuplicateNegationError } from "./runner-Bz3arOqh.js";
-import { o as isLazyCommand, s as lazy } from "./subcommand-router-Cskpofdk.js";
-import { a as symbols, i as styles, n as logger, r as setColorEnabled, t as isColorEnabled } from "./logger-i_bb-Jhc.js";
-import { a as generateCompletion, p as generateBundledCompletionWorker, s as withCompletionCommand } from "./completion-Ot2qpNNw.js";
-import "./src-D4QGGgW1.js";
-
-export { generateBundledCompletionWorker };

package/dist/subcommand-router-Cskpofdk.js

@@ -1,134 +0,0 @@
-//#region ../core/src/lazy.ts
-/**
-* Marker property for LazyCommand identification
-*/
-const LAZY_BRAND = "__politty_lazy__";
-/**
-* Type guard: check if a value is a LazyCommand
-*/
-function isLazyCommand(value) {
-	return typeof value === "object" && value !== null && LAZY_BRAND in value && value[LAZY_BRAND] === true;
-}
-/**
-* Create a lazily-loaded subcommand with synchronous metadata.
-*
-* The `meta` command provides names, descriptions, and args schema
-* for static analysis (completion scripts, help text) without loading
-* the full command module.
-*
-* The `load` function is called only at execution time.
-*
-* @example
-* ```ts
-* import { lazy, defineCommand } from "politty";
-*
-* const cli = defineCommand({
-*   name: "mycli",
-*   subCommands: {
-*     deploy: lazy(
-*       defineCommand({
-*         name: "deploy",
-*         description: "Deploy the application",
-*         args: z.object({ env: arg(z.string()) }),
-*       }),
-*       () => import("./deploy.js").then((m) => m.deployCommand),
-*     ),
-*   },
-* });
-* ```
-*/
-function lazy(meta, load) {
-	return {
-		[LAZY_BRAND]: true,
-		meta,
-		load
-	};
-}
-/**
-* Resolve synchronous metadata from a SubCommandValue.
-* Returns null for legacy async subcommands whose metadata is unavailable.
-*/
-function resolveSubCommandMeta(subCmd) {
-	if (isLazyCommand(subCmd)) return subCmd.meta;
-	if (typeof subCmd === "function") return null;
-	return subCmd;
-}
-
-//#endregion
-//#region ../core/src/executor/subcommand-router.ts
-/**
-* Resolve a lazy-loaded command (sync or async)
-*
-* @param cmd - The command or lazy loader function
-* @returns The resolved command
-*/
-async function resolveLazyCommand(cmd) {
-	if (isLazyCommand(cmd)) return await cmd.load();
-	if (typeof cmd === "function") return await cmd();
-	return cmd;
-}
-/**
-* Resolve a subcommand by name (including alias lookup) and return both the
-* resolved command and the canonical name if accessed via alias.
-*
-* This avoids a redundant alias scan when the caller needs both pieces of info.
-*/
-async function resolveSubcommandWithAlias(command, name) {
-	if (!command.subCommands) return;
-	const subCmd = Object.hasOwn(command.subCommands, name) ? command.subCommands[name] : void 0;
-	if (subCmd) return {
-		command: await resolveLazyCommand(subCmd),
-		aliasFor: void 0
-	};
-	const canonicalName = resolveSubCommandAlias(command, name);
-	if (canonicalName) return {
-		command: await resolveLazyCommand(command.subCommands[canonicalName]),
-		aliasFor: canonicalName
-	};
-}
-/**
-* Resolve an alias to the canonical subcommand name.
-* Returns the canonical name if the given name is an alias, or undefined.
-*
-* Note: Aliases are only recognized for eagerly-defined commands and
-* `lazy()` commands (which carry synchronous metadata). Pure async
-* subcommand functions do not expose metadata synchronously, so their
-* aliases cannot be resolved without loading the module.
-*
-* @param command - The parent command
-* @param alias - The alias to look up
-* @returns The canonical subcommand name, or undefined
-*/
-function resolveSubCommandAlias(command, alias) {
-	if (!command.subCommands) return void 0;
-	for (const [name, subCmd] of Object.entries(command.subCommands)) if (resolveSubCommandMeta(subCmd)?.aliases?.includes(alias)) return name;
-}
-/**
-* Build a set of all recognized subcommand names including aliases.
-*
-* @param command - The parent command
-* @returns Set of all names (canonical + aliases)
-*/
-function listSubCommandNamesWithAliases(command) {
-	const names = /* @__PURE__ */ new Set();
-	if (!command.subCommands) return names;
-	for (const [name, subCmd] of Object.entries(command.subCommands)) {
-		names.add(name);
-		const meta = resolveSubCommandMeta(subCmd);
-		if (meta?.aliases) for (const alias of meta.aliases) names.add(alias);
-	}
-	return names;
-}
-/**
-* List all subcommand names for a command
-*
-* @param command - The parent command
-* @returns Array of subcommand names
-*/
-function listSubCommands(command) {
-	if (!command.subCommands) return [];
-	return Object.keys(command.subCommands);
-}
-
-//#endregion
-export { resolveSubcommandWithAlias as a, resolveSubCommandMeta as c, resolveSubCommandAlias as i, listSubCommands as n, isLazyCommand as o, resolveLazyCommand as r, lazy as s, listSubCommandNamesWithAliases as t };