@politty/zod 0.0.0

package/dist/completion.d.ts

@@ -0,0 +1,242 @@
+import { C as Command, X as ResolvedFieldMeta, _ as DynamicCompletionResult, b as ArgsSchema, d as ExpandCompletion, g as DynamicCompletionResolver, h as DynamicCompletionContext, m as DynamicCompletionCandidate, p as CompletionDirectiveMask, v as AnyCommand } from "./arg-registry-YaWTVu_x.js";
+import { C as CompletionResult, D as InternalArgsSchema, E as InferInternalArgs, S as CompletionOptions, T as ValueCompletion, _ as CompletablePositional, a as detectShell, b as CompletionGenerator, c as withCompletionCommand, d as bundledWorkerShellExtension, f as defaultBundledWorkerOutputPath, g as CompletableOption, h as BundledWorkerOptions, i as createRefreshCompletionCommand, l as GenerateBundledCompletionWorkerOptions, m as validateBundledWorkerFile, n as createCompletionCommand, o as generateCompletion, p as generateBundledCompletionWorker, r as createCompletionWorkerPathCommand, s as getSupportedShells, t as WithCompletionOptions, u as GenerateBundledCompletionWorkerResult, v as CompletableSubcommand, w as ShellType, x as CompletionMode, y as CompletionData } from "./index-CvhsecfS.js";
+//#region ../core/src/completion/dynamic/context-parser.d.ts
+/**
+ * Completion type indicates what kind of completion is expected
+ */
+type CompletionType = "subcommand" | "option-name" | "option-value" | "positional";
+/**
+ * Context for completion at current cursor position
+ */
+interface CompletionContext {
+  /** Subcommand path from root (e.g., ["plugin", "add"]) */
+  subcommandPath: string[];
+  /** The resolved command at current path */
+  currentCommand: AnyCommand;
+  /** Current word being typed (may be partial) */
+  currentWord: string;
+  /** Previous word (useful for option value detection) */
+  previousWord: string;
+  /** What type of completion is expected */
+  completionType: CompletionType;
+  /** Target option when completing option value */
+  targetOption?: CompletableOption | undefined;
+  /** Positional index when completing positional argument */
+  positionalIndex?: number | undefined;
+  /** Available options for current command */
+  options: CompletableOption[];
+  /** Available subcommands */
+  subcommands: string[];
+  /** Available positionals */
+  positionals: CompletablePositional[];
+  /** Options already used (to avoid duplicates) */
+  usedOptions: Set<string>;
+  /** Number of positional arguments already provided */
+  providedPositionalCount: number;
+  /**
+   * Best-effort parsed values for the CURRENT command, keyed by camelCase
+   * field name. Includes positionals (single value or string[] for variadic
+   * positionals) and options (string for scalars, string[] for array
+   * options). Zod validation is NOT applied — values are raw strings.
+   */
+  parsedArgs: Record<string, unknown>;
+  /**
+   * Values already supplied for the option/positional currently being
+   * completed (for de-duplicating array options and oneof exclusivity in
+   * dynamic resolvers).
+   */
+  previousValues: string[];
+}
+/**
+ * Parse completion context from command line arguments
+ *
+ * @param argv - Arguments after the program name (e.g., ["build", "--fo"])
+ * @param rootCommand - The root command
+ * @param globalArgsSchema - Optional global args. When provided, options
+ *   derived from this schema are merged into every command level so dynamic
+ *   resolvers attached to global options can be reached from any subcommand.
+ * @returns Completion context
+ */
+declare function parseCompletionContext(argv: string[], rootCommand: AnyCommand, globalArgsSchema?: ArgsSchema): CompletionContext;
+//#endregion
+//#region ../core/src/completion/dynamic/candidate-generator.d.ts
+/**
+ * Completion directive flags (bitwise)
+ */
+declare const CompletionDirective: {
+  /** Default completion behavior */
+  readonly Default: 0;
+  /** Don't add space after completion */
+  readonly NoSpace: 1;
+  /** Don't offer file completion (even if no other completions) */
+  readonly NoFileCompletion: 2;
+  /** Filter completions using current word as prefix */
+  readonly FilterPrefix: 4;
+  /** Keep the order of completions */
+  readonly KeepOrder: 8;
+  /** Trigger file completion */
+  readonly FileCompletion: 16;
+  /** Trigger directory completion */
+  readonly DirectoryCompletion: 32;
+  /** Error occurred during completion */
+  readonly Error: 64;
+};
+/**
+ * A completion candidate
+ */
+interface CompletionCandidate {
+  /** The completion value */
+  value: string;
+  /** Optional description */
+  description?: string | undefined;
+  /** Type hint for display purposes */
+  type?: "option" | "subcommand" | "value" | "file" | "directory";
+}
+/**
+ * Result of candidate generation
+ */
+interface CandidateResult {
+  /** Completion candidates */
+  candidates: CompletionCandidate[];
+  /** Directive flags for shell behavior */
+  directive: number;
+  /** File extensions for shell-native filtering (e.g., ["json", "yaml"]) */
+  fileExtensions?: string[] | undefined;
+  /** Glob patterns for shell-native file matching (e.g., [".env.*"]) */
+  fileMatchers?: string[] | undefined;
+}
+/**
+ * Options for candidate generation.
+ */
+interface GenerateCandidatesOptions {
+  /**
+   * Target shell. Forwarded to dynamic resolvers so they can vary output
+   * (e.g. include descriptions only for shells that render them).
+   */
+  shell: ShellType;
+}
+/**
+ * Generate completion candidates based on context.
+ *
+ * Async because dynamic resolvers may return promises. Sync completion
+ * sources (choices/file/directory/command/none, subcommand, option name)
+ * still resolve synchronously and the await is a no-op for them.
+ *
+ * Inline option-value prefixes (`--field=foo`) on the option-value path
+ * are stripped here so resolvers and post-processing always see the
+ * value portion regardless of whether the caller pre-normalized.
+ */
+declare function generateCandidates(context: CompletionContext, options: GenerateCandidatesOptions): Promise<CandidateResult>;
+//#endregion
+//#region ../core/src/completion/dynamic/complete-command.d.ts
+/**
+ * Schema for the __complete command
+ */
+declare const completeArgsSchema: InternalArgsSchema<{
+  shell: "bash" | "fish" | "zsh";
+  args: string[];
+}>;
+type CompleteArgs = InferInternalArgs<typeof completeArgsSchema>;
+/**
+ * Create the dynamic completion command
+ *
+ * @param rootCommand - The root command to generate completions for
+ * @param programName - The program name (optional, defaults to rootCommand.name)
+ * @param globalArgsSchema - Global args schema. Forwarded to
+ *   `parseCompletionContext` so resolvers attached to global options remain
+ *   reachable at every subcommand level.
+ * @returns A command that outputs completion candidates
+ */
+declare function createDynamicCompleteCommand(rootCommand: AnyCommand, _programName?: string, globalArgsSchema?: ArgsSchema): Command<typeof completeArgsSchema, CompleteArgs, any>;
+/**
+ * Check if a command tree contains the __complete command
+ */
+declare function hasCompleteCommand(command: AnyCommand): boolean;
+//#endregion
+//#region ../core/src/completion/dynamic/shell-formatter.d.ts
+/**
+ * Options for shell-specific formatting
+ */
+interface ShellFormatOptions {
+  /** Target shell type */
+  shell: ShellType;
+  /** Current word being completed (used for prefix filtering) */
+  currentWord: string;
+  /** For bash: the prefix before '=' in --opt=value completions */
+  inlinePrefix?: string | undefined;
+}
+/**
+ * Format completion candidates for the specified shell
+ *
+ * @returns Shell-ready output string (lines separated by newline, last line is :directive)
+ */
+declare function formatForShell(result: CandidateResult, options: ShellFormatOptions): string;
+//#endregion
+//#region ../core/src/completion/extractor.d.ts
+/**
+ * Extract positional arguments from a command
+ */
+declare function extractPositionals(command: AnyCommand): ResolvedFieldMeta[];
+/**
+ * Extract completion data from a command tree
+ *
+ * @param command - The root command
+ * @param programName - Program name for completion scripts
+ * @param globalArgsSchema - Optional global args schema. When provided, global options
+ *   are derived from this schema instead of the root command's options.
+ */
+declare function extractCompletionData(command: AnyCommand, programName: string, globalArgsSchema?: ArgsSchema, validateOnly?: boolean): CompletionData;
+//#endregion
+//#region ../core/src/completion/value-completion-resolver.d.ts
+/**
+ * Sentinel returned when a field uses `completion.custom.expand`. The static
+ * extractor recognises this and replaces it with a fully resolved
+ * `{ type: "expand", ... }` ValueCompletion after sibling args' static
+ * values are known. Internal: never assigned onto `CompletableOption` /
+ * `CompletablePositional` directly; callers stash it in a side map keyed by
+ * field name and patch the resolved spec in afterwards.
+ */
+interface PendingExpandValueCompletion {
+  type: "pending-expand";
+  spec: ExpandCompletion;
+}
+/**
+ * Minimal field interface needed for resolving value completion.
+ * Both ResolvedFieldMeta and inline context-parser types satisfy this.
+ */
+interface ValueCompletionField {
+  completion?: ({
+    type?: string;
+    custom?: {
+      choices?: string[];
+      shellCommand?: string;
+      resolve?: DynamicCompletionResolver;
+      expand?: ExpandCompletion;
+    };
+  } & ({
+    extensions?: string[];
+    matcher?: never;
+  } | {
+    matcher?: string[];
+    extensions?: never;
+  })) | undefined;
+  enumValues?: string[] | undefined;
+  /** Field name surfaced in error messages when custom variants are mixed. */
+  name?: string;
+}
+/**
+ * Resolve value completion from field metadata.
+ *
+ * Priority (within `custom`): `expand` > `resolve` > `choices` > `shellCommand`.
+ * Specifying more than one of these on the same field throws so the
+ * misconfiguration surfaces at command-definition time rather than at
+ * completion time. The `expand` variant returns a sentinel — the extractor
+ * resolves it against sibling fields and replaces the sentinel with a
+ * `{ type: "expand", table, dependsOn }` entry.
+ *
+ * Outside `custom`: explicit `type` (file/directory/none) > auto-detected
+ * enum values from the schema.
+ */
+declare function resolveValueCompletion(field: ValueCompletionField): ValueCompletion | PendingExpandValueCompletion | undefined;
+//#endregion
+export { type BundledWorkerOptions, type CandidateResult, type CompletableOption, type CompletableSubcommand, type CompletionCandidate, type CompletionContext, type CompletionData, CompletionDirective, type CompletionDirectiveMask, type CompletionGenerator, type CompletionMode, type CompletionOptions, type CompletionResult, type CompletionType, type DynamicCompletionCandidate, type DynamicCompletionContext, type DynamicCompletionResolver, type DynamicCompletionResult, type GenerateBundledCompletionWorkerOptions, type GenerateBundledCompletionWorkerResult, type ShellFormatOptions, type ShellType, type ValueCompletionField, WithCompletionOptions, bundledWorkerShellExtension, createCompletionCommand, createCompletionWorkerPathCommand, createDynamicCompleteCommand, createRefreshCompletionCommand, defaultBundledWorkerOutputPath, detectShell, extractCompletionData, extractPositionals, formatForShell, generateBundledCompletionWorker, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, validateBundledWorkerFile, withCompletionCommand };

package/dist/completion.js

@@ -0,0 +1,4 @@
+import "./register-Bk0K83W2.js";
+import { _ as CompletionDirective, a as generateCompletion, b as resolveValueCompletion, c as createDynamicCompleteCommand, d as bundledWorkerShellExtension, f as defaultBundledWorkerOutputPath, g as extractPositionals, h as extractCompletionData, i as detectShell, l as hasCompleteCommand, m as validateBundledWorkerFile, n as createCompletionWorkerPathCommand, o as getSupportedShells, p as generateBundledCompletionWorker, r as createRefreshCompletionCommand, s as withCompletionCommand, t as createCompletionCommand, u as formatForShell, v as generateCandidates, y as parseCompletionContext } from "./completion-gtWX3mwP.js";
+
+export { CompletionDirective, bundledWorkerShellExtension, createCompletionCommand, createCompletionWorkerPathCommand, createDynamicCompleteCommand, createRefreshCompletionCommand, defaultBundledWorkerOutputPath, detectShell, extractCompletionData, extractPositionals, formatForShell, generateBundledCompletionWorker, generateCandidates, generateCompletion, getSupportedShells, hasCompleteCommand, parseCompletionContext, resolveValueCompletion, validateBundledWorkerFile, withCompletionCommand };