clap-ts 0.2.0 → 0.3.0

package/dist/parser.d.ts

@@ -1,32 +1,53 @@
 /**
- * Argument parser - delegates core tokenizing to node:util parseArgs,
- * then layers on: env fallback, type coercion, count/append actions,
- * numArgs with defaultMissingValue, global args, kebab-to-camel mapping,
- * subcommand detection, and default values.
+ * Argument parser.
  *
- * node:util parseArgs handles:
- *   --flag, --flag=value, --flag value, -f, -fvalue, -abc (combined booleans),
- *   -- separator, positionals
+ * Tokenizes argv directly against the command's own arg definitions. This
+ * replaced node:util parseArgs, which re-validates its entire `options` object
+ * on every call (~170ns per option, regardless of argv length) and cannot
+ * express multi-value options, value terminators, or subcommand boundaries.
  *
- * We handle on top:
- *   conflictsWith / requires (in validation.ts),
- *   env variable fallback, action: 'append' (via multiple:true), action: 'count',
- *   numArgs with defaultMissingValue, global args merge, valueParser enum validation
- *   (in validation.ts), number type coercion, kebab-to-camel mapping,
- *   required arg validation (in validation.ts), typo suggestions (in validation.ts),
- *   valueDelimiter splitting, function valueParser, trailingVarArg, last,
- *   allowHyphenValues, allowNegativeNumbers, inferLongArgs, defaultValueIf.
+ * Handled here: long/short/clustered flags, attached and `=` values, boolean
+ * negation, count and append actions, multi-token numArgs, optional values via
+ * defaultMissingValue, value delimiters, hyphen and negative-number values,
+ * positional assignment, trailing var args, `--` escape, subcommand
+ * boundaries, env fallback, conditional and static defaults, and
+ * kebab-to-camel key mapping.
+ *
+ * Constraint checks that need the whole picture (conflicts, requires, groups,
+ * possible values) live in validation.ts.
  */
-import type { ArgsDef, ParseResult, CommandDef } from './types.js';
-/** Get the raw argv slice (after the binary/script path). */
-export declare function getRawArgs(argv?: readonly string[]): string[];
+import type { ArgDef, ArgsDef, ParseResult, CommandDef, PossibleValue } from './types.js';
 export declare class CliParseError extends Error {
     constructor(message: string);
 }
+/** Convert kebab-case to camelCase: --config-path -> configPath */
+export declare function kebabToCamel(s: string): string;
+/**
+ * Get the raw argv slice (after the binary/script path). With `noBinaryName`
+ * the source is taken as-is, matching clap's Command::no_binary_name.
+ */
+export declare function getRawArgs(argv?: readonly string[], noBinaryName?: boolean): string[];
+/**
+ * The command's subcommands, building any lazy ones on first use and caching
+ * the result so the thunk runs at most once per command.
+ */
+export declare function subCommandsOf(command: CommandDef<any>): Record<string, CommandDef<any>>;
+/** Whether the command has any subcommand, without building the lazy ones. */
+export declare function hasSubCommands(command: CommandDef<any>): boolean;
+/**
+ * Normalize an arg's allowed values to PossibleValue records. Plain strings and
+ * PossibleValue objects can be mixed in the same list.
+ */
+export declare function possibleValues(def: ArgDef): readonly PossibleValue[];
+/** Whether a raw value matches this possible value, by name or alias. */
+export declare function matchesPossibleValue(candidate: PossibleValue, value: string, ignoreCase: boolean): boolean;
+export declare function coerceValue(value: string, def: ArgDef, argName: string): string | number | boolean;
 /**
  * Parse raw argument tokens against a command definition.
  *
- * Uses node:util parseArgs for core tokenizing, then layers on all clap-ts features.
+ * Stops at the first bare token matching a subcommand name or alias; the
+ * remaining tokens are returned as `subCommandArgs` for the caller to parse
+ * against that subcommand.
  */
 export declare function parseArgs(rawArgs: readonly string[], command: CommandDef): ParseResult;
 /**