@wentools/zli 0.2.0-beta.2dc33a43

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/index.d.ts

@@ -0,0 +1,156 @@
+import { err as _Err, ok, type Result, type Err, ResultAsync, okAsync as neverthrowOkAsync } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+declare const makeErr: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+declare const errAsync: <const TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>>(type: TType, message: string, additional?: TAdditional) => ResultAsync<never, {
+    type: TType;
+    message: string;
+} & TAdditional>;
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+declare const okAsync: typeof neverthrowOkAsync;
+/**
+ * Utility type for defining error types concisely
+ *
+ * @example
+ * // Instead of:
+ * type UserNotFoundError = {
+ *   type: 'user_not_found'
+ *   message: string
+ *   userId: UserId
+ * }
+ *
+ * // Write:
+ * type UserNotFoundError = ErrorType<'user_not_found', { userId: UserId }>
+ *
+ * @example
+ * // Error without additional properties:
+ * type InvalidOperationError = ErrorType<'invalid_operation'>
+ */
+type ErrorType<TType extends string, TAdditional extends Record<string, unknown> = Record<string, never>> = {
+    type: TType;
+    message: string;
+} & TAdditional;
+/**
+ * Extract the error type from a Result or Promise<Result>
+ *
+ * @example
+ * // From async function
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractError<ReturnType<typeof getUser>>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // From Result type directly
+ * type MyResult = Result<User, InvalidError>
+ * type MyError = ExtractError<MyResult>
+ * // Type: InvalidError
+ *
+ * @example
+ * // Works with composed errors
+ * const replaceVersion = async (): Promise<Result<Version, VersionNotFoundError | VersionExistsError>> => { ... }
+ * type ReplaceError = ExtractError<ReturnType<typeof replaceVersion>>
+ * // Type: VersionNotFoundError | VersionExistsError
+ */
+type ExtractError<TResultOrPromise> = TResultOrPromise extends Promise<Result<unknown, infer TError>> ? TError : TResultOrPromise extends Result<unknown, infer TError> ? TError : never;
+/**
+ * Extract the error type from a function that returns Result or Promise<Result>
+ *
+ * @example
+ * // Simple extraction
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * type GetUserError = ExtractFnError<typeof getUser>
+ * // Type: UserNotFoundError
+ *
+ * @example
+ * // Compose errors from multiple functions
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * type CombinedError = ExtractFnError<typeof getUser> | ExtractFnError<typeof getImage>
+ * // Type: UserNotFoundError | ImageNotFoundError
+ */
+type ExtractFnError<TFunction extends (...args: unknown[]) => unknown> = ExtractError<ReturnType<TFunction>>;
+/**
+ * Extract and combine error types from multiple Result or Promise<Result> types
+ *
+ * @example
+ * type UserResult = Result<User, UserNotFoundError>
+ * type ImageResult = Promise<Result<Image, ImageNotFoundError>>
+ * type ProductResult = Result<Product, ProductNotFoundError>
+ *
+ * type CombinedError = ExtractErrors<[UserResult, ImageResult, ProductResult]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractErrors<TResults extends readonly unknown[]> = TResults extends readonly [
+    infer TFirst,
+    ...infer TRest
+] ? ExtractError<TFirst> | ExtractErrors<TRest> : never;
+/**
+ * Extract and combine error types from multiple functions that return Result or Promise<Result>
+ *
+ * @example
+ * const getUser = async (id: string): Promise<Result<User, UserNotFoundError>> => { ... }
+ * const getImage = async (id: string): Promise<Result<Image, ImageNotFoundError>> => { ... }
+ * const deleteProduct = async (id: string): Promise<Result<void, ProductNotFoundError>> => { ... }
+ *
+ * type CombinedError = ExtractFnsError<[typeof getUser, typeof getImage, typeof deleteProduct]>
+ * // Type: UserNotFoundError | ImageNotFoundError | ProductNotFoundError
+ */
+type ExtractFnsError<TFunctions extends readonly ((...args: unknown[]) => unknown)[]> = TFunctions extends readonly [
+    infer TFirst,
+    ...infer TRest extends readonly ((...args: unknown[]) => unknown)[]
+] ? ExtractFnError<TFirst & ((...args: unknown[]) => unknown)> | ExtractFnsError<TRest> : never;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+declare const rawErr: typeof _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export type { Result, Err, ErrorType, ExtractError, ExtractFnError, ExtractErrors, ExtractFnsError };
+export { err } from './err/index.js';
+export { isResult } from './is_result/index.js';
+export { propagateErr } from './propagate_err/index.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/index.ts"],"names":[],"mappings":"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"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/index.js

@@ -0,0 +1,65 @@
+import { err as _Err, ok, ResultAsync, errAsync as neverthrowErrAsync, okAsync as neverthrowOkAsync, } from 'neverthrow';
+/**
+ * Create an error object with literal type preservation
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found')
+ * // ✅ Type: { type: 'not_found', message: string }
+ *
+ * @example
+ * const error = makeErr('not_found', 'User not found', { userId: '123' })
+ * // ✅ Type: { type: 'not_found', message: string, userId: string }
+ */
+const makeErr = (type, message, additional) => ({
+    ...additional,
+    type,
+    message,
+});
+/**
+ * Create an async Err ResultAsync with automatic literal type preservation
+ *
+ * Async version of err() - same signature, returns ResultAsync instead of Result.
+ * Uses TypeScript 5.0+ const type parameters to preserve literal types automatically.
+ *
+ * @example
+ * // ✅ Simple error
+ * return errAsync('not_found', 'User not found')
+ * // Type: ResultAsync<never, { type: 'not_found', message: string }>
+ *
+ * @example
+ * // ✅ Error with additional properties
+ * return errAsync('not_found', 'User not found', { userId: '123' })
+ * // Type: ResultAsync<never, { type: 'not_found', message: string, userId: string }>
+ *
+ * @example
+ * // ✅ Error with complex additional data
+ * return errAsync('validation_failed', 'Invalid input', {
+ *   field: 'email',
+ *   errors: ['Invalid format']
+ * })
+ * // Type: ResultAsync<never, { type: 'validation_failed', message: string, field: string, errors: string[] }>
+ */
+const errAsync = (type, message, additional) => neverthrowErrAsync({
+    ...additional,
+    type,
+    message,
+});
+/**
+ * Re-export okAsync from neverthrow for consistency
+ * Creates a successful ResultAsync
+ */
+const okAsync = neverthrowOkAsync;
+/**
+ * Raw error function from neverthrow - use for lifting database errors directly
+ *
+ * @example
+ * const seedResult = await songSeeds.get.one.byId(songSeedId)
+ * if (seedResult.isErr()) {
+ *   return rawErr(seedResult.error)
+ * }
+ */
+const rawErr = _Err;
+export { makeErr, errAsync, ok, okAsync, rawErr, _Err, ResultAsync };
+export { err } from './err/index.js';
+export { isResult } from './is_result/index.js';
+export { propagateErr } from './propagate_err/index.js';

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.d.ts

@@ -0,0 +1,2 @@
+export { isResult } from './is_result.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/index.js

@@ -0,0 +1 @@
+export { isResult } from './is_result.js';

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+declare const isResult: (value: unknown) => value is {
+    isOk: () => boolean;
+    isErr: () => boolean;
+};
+export { isResult };
+//# sourceMappingURL=is_result.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_result.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI;IAAE,IAAI,EAAE,MAAM,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,OAAO,CAAA;CAStF,CAAA;AAED,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/is_result/is_result.js

@@ -0,0 +1,14 @@
+/**
+ * Check if a value is a neverthrow Result type
+ *
+ * Uses duck typing to detect Result objects without importing neverthrow types.
+ */
+const isResult = (value) => {
+    return (value !== null &&
+        typeof value === 'object' &&
+        'isOk' in value &&
+        'isErr' in value &&
+        typeof value.isOk === 'function' &&
+        typeof value.isErr === 'function');
+};
+export { isResult };

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.d.ts

@@ -0,0 +1,2 @@
+export { propagateErr } from './propagate_err.js';
+//# sourceMappingURL=index.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/index.js

@@ -0,0 +1 @@
+export { propagateErr } from './propagate_err.js';

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.d.ts

@@ -0,0 +1,28 @@
+import type { Result } from 'neverthrow';
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+declare const propagateErr: <TNew, E>(errorResult: Result<unknown, E>) => Result<TNew, E>;
+export { propagateErr };
+//# sourceMappingURL=propagate_err.d.ts.map

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate_err.d.ts","sourceRoot":"","sources":["../../../../../../../../src/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,YAAY,GAAI,IAAI,EAAE,CAAC,EAAE,aAAa,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,IAAI,EAAE,CAAC,CAI9E,CAAA;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/esm/deps/jsr.io/@wentools/result/0.1.0/src/propagate_err/propagate_err.js

@@ -0,0 +1,30 @@
+/**
+ * Propagates an error Result to a different success type context.
+ *
+ * This is safe because error Results never contain the success value - only the error.
+ * TypeScript's structural typing prevents direct assignment of Result<T, E> to Result<U, E>
+ * even though the error type is identical and we're in the error branch.
+ *
+ * Common use case: Early return from a function that creates multiple items. If creating
+ * item 2 fails with Result<Item, DatabaseError>, we need to return Result<Item[], DatabaseError>.
+ *
+ * @example
+ * const result = await createUser(db, data) // Result<User, DatabaseError>
+ * if (result.isErr()) {
+ *   // Need to return Result<Profile, DatabaseError> but have Result<User, DatabaseError>
+ *   return propagateErr(result)
+ * }
+ *
+ * @example
+ * // In bulk creation, propagate single-item error to array context
+ * const itemResult = await createItem(data) // Result<Item, Error>
+ * if (itemResult.isErr()) {
+ *   return propagateErr<Item[], Error>(itemResult) // Result<Item[], Error>
+ * }
+ */
+const propagateErr = (errorResult) => {
+    // Type assertion is safe: we're only propagating errors, and error Results
+    // don't contain the success value. The error type E is preserved exactly.
+    return errorResult;
+};
+export { propagateErr };

package/esm/detect_arg_conflicts/detect_arg_conflicts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Detect conflicts in argument definitions
+ *
+ * Checks for:
+ * - Duplicate arg names
+ * - Duplicate short names
+ *
+ * Returns list of conflicts found.
+ */
+import type { Arg } from '../arg.js';
+type ArgConflict = {
+    type: 'duplicate_name' | 'duplicate_short';
+    name: string;
+    conflictingArgs: string[];
+};
+declare const detectArgConflicts: (args: readonly Arg[]) => ArgConflict[];
+export { detectArgConflicts };
+export type { ArgConflict };
+//# sourceMappingURL=detect_arg_conflicts.d.ts.map

package/esm/detect_arg_conflicts/detect_arg_conflicts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect_arg_conflicts.d.ts","sourceRoot":"","sources":["../../src/detect_arg_conflicts/detect_arg_conflicts.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAA;AAEpC,KAAK,WAAW,GAAG;IAClB,IAAI,EAAE,gBAAgB,GAAG,iBAAiB,CAAA;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,eAAe,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,QAAA,MAAM,kBAAkB,GAAI,MAAM,SAAS,GAAG,EAAE,KAAG,WAAW,EA8C7D,CAAA;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAA;AAC7B,YAAY,EAAE,WAAW,EAAE,CAAA"}

package/esm/detect_arg_conflicts/detect_arg_conflicts.js

@@ -0,0 +1,54 @@
+/**
+ * Detect conflicts in argument definitions
+ *
+ * Checks for:
+ * - Duplicate arg names
+ * - Duplicate short names
+ *
+ * Returns list of conflicts found.
+ */
+const detectArgConflicts = (args) => {
+    const conflicts = [];
+    const namesSeen = new Map();
+    const shortsSeen = new Map();
+    for (const arg of args) {
+        // Check for duplicate names
+        if (namesSeen.has(arg.name)) {
+            namesSeen.get(arg.name).push(arg.name);
+        }
+        else {
+            namesSeen.set(arg.name, [arg.name]);
+        }
+        // Check for duplicate shorts
+        if (arg.short) {
+            if (shortsSeen.has(arg.short)) {
+                shortsSeen.get(arg.short).push(arg.name);
+            }
+            else {
+                shortsSeen.set(arg.short, [arg.name]);
+            }
+        }
+    }
+    // Report duplicate names
+    for (const [name, argNames] of namesSeen) {
+        if (argNames.length > 1) {
+            conflicts.push({
+                type: 'duplicate_name',
+                name,
+                conflictingArgs: argNames,
+            });
+        }
+    }
+    // Report duplicate shorts
+    for (const [short, argNames] of shortsSeen) {
+        if (argNames.length > 1) {
+            conflicts.push({
+                type: 'duplicate_short',
+                name: short,
+                conflictingArgs: argNames,
+            });
+        }
+    }
+    return conflicts;
+};
+export { detectArgConflicts };

package/esm/detect_arg_conflicts/mod.d.ts

@@ -0,0 +1,3 @@
+export { detectArgConflicts } from './detect_arg_conflicts.js';
+export type { ArgConflict } from './detect_arg_conflicts.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/detect_arg_conflicts/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/detect_arg_conflicts/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA"}

package/esm/detect_arg_conflicts/mod.js

@@ -0,0 +1 @@
+export { detectArgConflicts } from './detect_arg_conflicts.js';

package/esm/generate_help_text/generate_help_text.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate help text for commands
+ *
+ * Creates formatted help text showing:
+ * - Description
+ * - Usage line
+ * - Positional args
+ * - Flags
+ */
+import type { Command } from '../create_command.js';
+declare const generateHelpText: (command: Command, commandName?: string) => string;
+export { generateHelpText };
+//# sourceMappingURL=generate_help_text.d.ts.map

package/esm/generate_help_text/generate_help_text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_help_text.d.ts","sourceRoot":"","sources":["../../src/generate_help_text/generate_help_text.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAA;AAEnD,QAAA,MAAM,gBAAgB,GAAI,SAAS,OAAO,EAAE,cAAc,MAAM,KAAG,MAoDlE,CAAA;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/esm/generate_help_text/generate_help_text.js

@@ -0,0 +1,54 @@
+/**
+ * Generate help text for commands
+ *
+ * Creates formatted help text showing:
+ * - Description
+ * - Usage line
+ * - Positional args
+ * - Flags
+ */
+const generateHelpText = (command, commandName) => {
+    const lines = [];
+    // Description
+    if (command.description) {
+        lines.push(command.description);
+        lines.push('');
+    }
+    // Usage line
+    const usageParts = [];
+    if (commandName) {
+        usageParts.push(commandName);
+    }
+    const positionals = command.args.filter((arg) => arg.type === 'positional');
+    const flags = command.args.filter((arg) => arg.type === 'flag');
+    for (const arg of positionals) {
+        usageParts.push(`<${arg.name}>`);
+    }
+    if (flags.length > 0) {
+        usageParts.push('[options]');
+    }
+    lines.push(`Usage: ${usageParts.join(' ')}`);
+    lines.push('');
+    // Positional arguments
+    if (positionals.length > 0) {
+        lines.push('Arguments:');
+        for (const arg of positionals) {
+            const shortPart = arg.short ? `, -${arg.short}` : '';
+            const descPart = arg.description ? `  ${arg.description}` : '';
+            lines.push(`  ${arg.name}${shortPart}${descPart}`);
+        }
+        lines.push('');
+    }
+    // Flags
+    if (flags.length > 0) {
+        lines.push('Options:');
+        for (const arg of flags) {
+            const shortPart = arg.short ? `-${arg.short}, ` : '';
+            const descPart = arg.description ? `  ${arg.description}` : '';
+            lines.push(`  ${shortPart}--${arg.name}${descPart}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+};
+export { generateHelpText };

package/esm/generate_help_text/mod.d.ts

@@ -0,0 +1,2 @@
+export { generateHelpText } from './generate_help_text.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/generate_help_text/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/generate_help_text/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA"}

package/esm/generate_help_text/mod.js

@@ -0,0 +1 @@
+export { generateHelpText } from './generate_help_text.js';

package/esm/infer_args_type.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Type utilities for inferring handler arg types from Zod schemas
+ *
+ * Extracts the TypeScript type from an array of arg definitions.
+ */
+import type { z } from 'zod';
+import type { Arg } from './arg.js';
+/**
+ * Infer the handler args object type from an array of arg definitions
+ *
+ * Takes an array like:
+ *   [
+ *     { name: 'email', schema: z.string().email() },
+ *     { name: 'verbose', schema: z.boolean().optional() }
+ *   ]
+ *
+ * And produces:
+ *   { email: string, verbose?: boolean }
+ */
+type InferArgsType<TArgs extends readonly Arg[]> = TArgs extends readonly [
+    infer First,
+    ...infer Rest
+] ? First extends Arg ? Rest extends readonly Arg[] ? {
+    [K in First['name']]: z.infer<First['schema']>;
+} & InferArgsType<Rest> : {
+    [K in First['name']]: z.infer<First['schema']>;
+} : never : Record<string, never>;
+export type { InferArgsType };
+//# sourceMappingURL=infer_args_type.d.ts.map

package/esm/infer_args_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer_args_type.d.ts","sourceRoot":"","sources":["../src/infer_args_type.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAC5B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;;;;;;;GAWG;AACH,KAAK,aAAa,CAAC,KAAK,SAAS,SAAS,GAAG,EAAE,IAAI,KAAK,SAAS,SAAS;IACzE,MAAM,KAAK;IACX,GAAG,MAAM,IAAI;CACb,GACE,KAAK,SAAS,GAAG,GAChB,IAAI,SAAS,SAAS,GAAG,EAAE,GAC1B;KAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;CAAE,GAAG,aAAa,CAAC,IAAI,CAAC,GACxE;KAAG,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;CAAE,GACnD,KAAK,GACN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;AAExB,YAAY,EAAE,aAAa,EAAE,CAAA"}

package/esm/infer_args_type.js

@@ -0,0 +1,6 @@
+/**
+ * Type utilities for inferring handler arg types from Zod schemas
+ *
+ * Extracts the TypeScript type from an array of arg definitions.
+ */
+export {};

package/esm/is_boolean_schema/is_boolean_schema.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if a Zod schema is a boolean type
+ *
+ * Uses internal Zod _def API, isolated here for easy testing and maintenance.
+ * If Zod changes their internal structure, we only need to update this function.
+ *
+ * Handles wrapped schemas (default, optional, nullable) by recursively unwrapping.
+ */
+import type { ZodSchema } from 'zod';
+declare const isBooleanSchema: (schema: ZodSchema) => boolean;
+export { isBooleanSchema };
+//# sourceMappingURL=is_boolean_schema.d.ts.map

package/esm/is_boolean_schema/is_boolean_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is_boolean_schema.d.ts","sourceRoot":"","sources":["../../src/is_boolean_schema/is_boolean_schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAEpC,QAAA,MAAM,eAAe,GAAI,QAAQ,SAAS,KAAG,OAa5C,CAAA;AAED,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/esm/is_boolean_schema/is_boolean_schema.js

@@ -0,0 +1,21 @@
+/**
+ * Check if a Zod schema is a boolean type
+ *
+ * Uses internal Zod _def API, isolated here for easy testing and maintenance.
+ * If Zod changes their internal structure, we only need to update this function.
+ *
+ * Handles wrapped schemas (default, optional, nullable) by recursively unwrapping.
+ */
+const isBooleanSchema = (schema) => {
+    // Direct boolean check
+    if ('type' in schema._def && schema._def.type === 'boolean') {
+        return true;
+    }
+    // Unwrap wrappers (ZodDefault, ZodOptional, ZodNullable)
+    // These store the inner schema in _def.innerType
+    if ('innerType' in schema._def) {
+        return isBooleanSchema(schema._def.innerType);
+    }
+    return false;
+};
+export { isBooleanSchema };

package/esm/is_boolean_schema/mod.d.ts

@@ -0,0 +1,2 @@
+export { isBooleanSchema } from './is_boolean_schema.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/is_boolean_schema/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/is_boolean_schema/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA"}

package/esm/is_boolean_schema/mod.js

@@ -0,0 +1 @@
+export { isBooleanSchema } from './is_boolean_schema.js';

package/esm/mod.d.ts

@@ -0,0 +1,8 @@
+export { zli } from './zli.js';
+export type { CommandDirectory, CommandEntry } from './run.js';
+export type { Command, CommandHandler, CommandOptions, MaybeResult } from './create_command.js';
+export type { PositionalArg, PositionalArgOptions } from './create_positional_arg.js';
+export type { FlagArg, FlagArgOptions } from './create_flag_arg.js';
+export type { Arg } from './arg.js';
+export type { InferArgsType } from './infer_args_type.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAC9D,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAC/F,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACrF,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACnE,YAAY,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AACnC,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA"}

package/esm/mod.js

@@ -0,0 +1 @@
+export { zli } from './zli.js';

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/parse_args/mod.d.ts

@@ -0,0 +1,3 @@
+export { parseArgs } from './parse_args.js';
+export type { RawValues } from './parse_args.js';
+//# sourceMappingURL=mod.d.ts.map

package/esm/parse_args/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/parse_args/mod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA"}