zod-args-parser 1.2.8 → 2.0.0-beta.0

package/src/types/io-types.ts

@@ -0,0 +1,131 @@
+import type { Context, ContextWide } from "./context-types.ts";
+import type { Argument, Cli, Option, Subcommand } from "./definitions-types.ts";
+import type { InferSchemaInputType, InferSchemaOutputType } from "./schema-types.ts";
+import type { Prettify, ToOptional, AllowUndefinedIfOptional as AddUndefinedIfAllOptional } from "./utilities-types.ts";
+
+/** Output options type */
+type OptionsOutputType<T extends Record<string, Option>> = Prettify<
+  ToOptional<{ [K in keyof T]: InferSchemaOutputType<T[K]["schema"]> }>
+>;
+
+/** Input options type */
+type OptionsInputType<T extends Record<string, Option>> = Prettify<
+  ToOptional<{ [K in keyof T]: InferSchemaInputType<T[K]["schema"]> }>
+>;
+
+/** Output arguments type */
+type ArgumentsOutputType<T extends Record<string, Argument>> = Prettify<
+  ToOptional<{ [K in keyof T]: InferSchemaOutputType<T[K]["schema"]> }>
+>;
+
+/** Input arguments type */
+type ArgumentsInputType<T extends Record<string, Argument>> = Prettify<
+  ToOptional<{ [K in keyof T]: InferSchemaInputType<T[K]["schema"]> }>
+>;
+
+/**
+ * - Infer options output type.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", options: [...] });
+ *   type MyCommandOptionsOutput = InferOptionsOutputType<typeof myCommand>;
+ */
+export type InferOptionsOutputType<T extends Cli | Subcommand> =
+  T["options"] extends Record<string, Option> ? OptionsOutputType<T["options"]> : undefined;
+
+/**
+ * - Infer arguments output type.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", arguments: [...] });
+ *   type MyCommandArgumentsOutput = InferArgumentsOutputType<typeof myCommand>;
+ */
+export type InferArgumentsOutputType<T extends Cli | Subcommand> =
+  T["arguments"] extends Record<string, Argument> ? ArgumentsOutputType<T["arguments"]> : undefined;
+
+/**
+ * - Infer arguments input type.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", arguments: [...] });
+ *   type MyCommandArgumentsInput = InferArgumentsInputType<typeof myCommand>;
+ */
+export type InferArgumentsInputType<T extends Cli | Subcommand> =
+  T["arguments"] extends Record<string, Argument> ? ArgumentsInputType<T["arguments"]> : undefined;
+
+/**
+ * - Infer options input type.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", options: [...] });
+ *   type MyCommandOptionsInput = inferOptionsInputType<typeof myCommand>;
+ */
+export type inferOptionsInputType<T extends Cli | Subcommand> =
+  T["options"] extends Record<string, Option> ? OptionsInputType<T["options"]> : undefined;
+
+/**
+ * - Infer options, arguments, and positionals input types from the CLI/subcommand definition.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", ... });
+ *   type MyCommandInput = InferInputType<typeof myCommand>;
+ */
+export type InferInputType<T extends Cli | Subcommand> = Prettify<
+  // Add undefined if all properties are optional
+  AddUndefinedIfAllOptional<
+    // Make properties that can be undefined optional
+    ToOptional<{
+      positionals: T["allowPositionals"] extends true ? string[] : undefined;
+
+      options: T["options"] extends Record<string, Option>
+        ? // Add undefined if all properties are optional
+          AddUndefinedIfAllOptional<
+            // Options types as record
+            OptionsInputType<T["options"]>
+          >
+        : undefined;
+
+      arguments: T["arguments"] extends Record<string, Argument>
+        ? // Add undefined if all properties are optional
+          AddUndefinedIfAllOptional<
+            // Arguments types as record
+            ArgumentsInputType<T["arguments"]>
+          >
+        : undefined;
+    }>
+  >
+>;
+
+export interface InputTypeWide {
+  arguments?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+  positionals?: string[];
+}
+
+/**
+ * - Infer schema output type.
+ *
+ * @example
+ *   const myCommand = defineSubcommand({ name: "my-command", ... });
+ *   type MyCommandOutput = InferOutputType<typeof myCommand>;
+ */
+export type InferOutputType<T extends Cli | Subcommand> = Prettify<{
+  subcommand: "name" extends keyof T ? T["name"] : undefined;
+  options: T["options"] extends Record<string, Option> ? OptionsOutputType<T["options"]> : never;
+  arguments: T["arguments"] extends Record<string, Argument> ? ArgumentsOutputType<T["arguments"]> : never;
+  positionals: T["allowPositionals"] extends true ? string[] : never;
+  context: Context<[T]>;
+}>;
+
+/** Same as `InferOutputType` but for multiple subcommands/cli */
+export type OutputType<S extends readonly (Cli | Subcommand)[]> = {
+  [K in keyof S]: InferOutputType<S[K]>;
+}[number];
+
+export interface OutputTypeWide {
+  subcommand: string | undefined;
+  positionals?: string[];
+  arguments?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+  context: ContextWide;
+}

package/src/types/metadata-types.ts

@@ -0,0 +1,104 @@
+import type { SchemaType } from "./schema-types.ts";
+
+interface MetadataBase {
+  /** Empty string if not provided */
+  description: string;
+
+  /** Empty string if not provided */
+  descriptionMarkdown: string;
+
+  /** Empty string if not provided */
+  example: string;
+
+  /** Whether the metadata is hidden from the documentation. */
+  hidden: boolean;
+}
+
+export interface CliMetadata extends Omit<MetadataBase, "hidden"> {
+  /** The name of the cli program. */
+  name: string;
+
+  /** Empty string if not provided */
+  usage: string;
+
+  /** Whether the cli program allows positionals arguments. */
+  allowPositionals: boolean;
+
+  /** Empty array if not provided */
+  options: OptionMetadata[];
+
+  /** Empty array if not provided */
+  arguments: ArgumentMetadata[];
+
+  /** Empty array if not provided */
+  subcommands: SubcommandMetadata[];
+}
+
+export interface SubcommandMetadata extends MetadataBase {
+  /** The subcommand name. */
+  name: string;
+
+  /** Empty array if not provided */
+  aliases: string[];
+
+  /** Empty string if not provided */
+  placeholder: string;
+
+  /** Empty string if not provided */
+  usage: string;
+
+  /** Whether the subcommand allows positionals arguments. */
+  allowPositionals: boolean;
+
+  /** Empty array if not provided */
+  options: OptionMetadata[];
+
+  /** Empty array if not provided */
+  arguments: ArgumentMetadata[];
+}
+
+export interface OptionMetadata extends MetadataBase {
+  /** The option name. */
+  name: string;
+
+  /** The option name as argument. E.g. `--option-name` */
+  nameAsArg: string;
+
+  /** Empty array if not provided. */
+  aliases: string[];
+
+  /** Empty array if not provided. E.g. `[--alias-name, ...]` */
+  aliasesAsArgs: string[];
+
+  /** Empty string if not provided */
+  placeholder: string;
+
+  /** The default value of the option. */
+  defaultValue: unknown;
+
+  /** Empty string if not provided. */
+  defaultValueAsString: string;
+
+  /** Is optional. */
+  optional: boolean;
+
+  /** Standard Schema V1. */
+  schema: SchemaType;
+}
+
+export interface ArgumentMetadata extends MetadataBase {
+  /** The argument name. */
+  name: string;
+
+  /** The default value of the argument. */
+  defaultValue: unknown;
+
+  /** The default value of the argument as string. */
+  defaultValueAsString: string;
+
+  /** Is optional. */
+  optional: boolean;
+
+  /** Standard Schema V1. */
+  schema: SchemaType;
+}

package/src/types/schema-types.ts

@@ -0,0 +1,9 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+export type SchemaType<T = unknown> = StandardSchemaV1<T>;
+
+export type InferSchemaInputType<T extends SchemaType> = StandardSchemaV1.InferInput<T>;
+
+export type InferSchemaOutputType<T extends SchemaType> = StandardSchemaV1.InferOutput<T>;
+
+export type SchemaResult<T = unknown> = StandardSchemaV1.Result<T>;

package/src/types/types.ts

@@ -0,0 +1,72 @@
+import type { Cli, Subcommand } from "./definitions-types.ts";
+import type { PrintHelpOptions } from "./help-message-types.ts";
+import type { InferInputType, InputTypeWide, OutputType, OutputTypeWide } from "./io-types.ts";
+
+type PrimitiveTypeNames = "string" | "number" | "boolean" | "object" | "unknown";
+export type CoerceTypes = PrimitiveTypeNames | `${PrimitiveTypeNames}[]` | `set<${PrimitiveTypeNames}>` | (string & {});
+
+export interface CoerceMethod<Value> {
+  (terminalInput: string): Value;
+  type?: CoerceTypes;
+}
+
+type GetSubcommandsNames<T extends Partial<Subcommand>> = T extends Cli
+  ? T["subcommands"] extends infer S extends readonly [Subcommand, ...Subcommand[]]
+    ? { [Index in keyof S]: S[Index] extends { name: string } ? S[Index]["name"] : never }[number]
+    : never
+  : never;
+
+type Unsubscribe = () => void;
+
+export interface AttachedMethods<T extends Cli | Subcommand> {
+  /**
+   * Add a handler to be called when the subcommand/cli is executed.
+   *
+   * @example
+   *   const unsubscribe = cli.onExecute(result => console.log(result));
+   */
+  onExecute: (handler: (data: OutputType<[T]>) => void) => Unsubscribe;
+
+  // Make the argument optional if it has undefined type
+  execute: InferInputType<T> extends infer InputType
+    ? undefined extends InputType
+      ? (input?: InputType) => void
+      : (input: InputType) => void
+    : never;
+
+  /** **WARNING**: This will only be available after the CLI schema has been created */
+  generateCliHelpMessage?: (options?: PrintHelpOptions) => string;
+
+  /**
+   * **WARNING**: This will only be available after the CLI schema has been created
+   *
+   * @throws {Error} - When the subcommand is not found
+   */
+  generateSubcommandHelpMessage?: (
+    subcommandName: GetSubcommandsNames<T> | (string & {}),
+    options?: PrintHelpOptions,
+  ) => string;
+}
+
+export interface AttachedMethodsWide {
+  onExecute: (handler: (data: OutputTypeWide) => void) => Unsubscribe;
+  execute: (input?: InputTypeWide) => void;
+  generateCliHelpMessage?: (options?: PrintHelpOptions) => void;
+  /** @throws {Error} - When the subcommand is not found */
+  generateSubcommandHelpMessage?: (subcommandName: string, options?: PrintHelpOptions) => void;
+}
+
+export type CliOutputType<S extends Cli> =
+  | OutputType<[S]>
+  | (S["subcommands"] extends readonly [Subcommand, ...Subcommand[]] ? OutputType<S["subcommands"]> : never);
+
+export type CliParseResult<S extends Cli> =
+  | { value: CliOutputType<S>; error?: undefined }
+  | { value?: never; error: Error };
+
+export type CliParseResultWide = { value: OutputTypeWide; error?: undefined } | { value?: never; error: Error };
+
+export interface ValidateMethods<S extends Cli> {
+  run(input: string | string[]): CliParseResult<S>;
+  runAsync(input: string | string[]): Promise<CliParseResult<S>>;
+}

package/src/types/utilities-types.ts

@@ -0,0 +1,26 @@
+/** `{ some props } & { other props }` => `{ some props, other props }` */
+export type Prettify<T> = { [K in keyof T]: T[K] } & {};
+
+/** Extract the undefined properties from an object */
+export type UndefinedProperties<T> = { [P in keyof T]-?: undefined extends T[P] ? P : never }[keyof T];
+
+/** Make undefined properties optional? */
+export type ToOptional<T> = Partial<Pick<T, UndefinedProperties<T>>> &
+  Pick<T, Exclude<keyof T, UndefinedProperties<T>>>;
+
+/** If every property in a record is optional, widen the type to `T | undefined`. */
+export type AllowUndefinedIfOptional<T> = {
+  [K in keyof T]-?: object extends Pick<T, K> ? never : K;
+}[keyof T] extends never
+  ? T | undefined
+  : T;
+
+/** Widen literal and tuples */
+// prettier-ignore
+export type Widen<T> =
+  T extends string ? string :
+  T extends number ? number :
+  T extends boolean ? boolean :
+  T extends readonly (infer U)[] ? Widen<U>[] :
+  T extends Set<infer U> ? Set<Widen<U>> :
+  T;

package/src/utilities.ts

@@ -1,21 +1,56 @@
-import { SubcommandMetadata } from "./metadata/metadata-types.js";
+import type { Argument, Option, PreparedType } from "./types/definitions-types.ts";
+import type { SubcommandMetadata } from "./types/metadata-types.ts";
+import type { SchemaResult, SchemaType } from "./types/schema-types.ts";
+import type { CoerceMethod } from "./types/types.ts";
 
-/**
- * Converts a string to its corresponding boolean value if the string is "true" or "false" (case-insensitive).
- *
- * @param string - The input string to convert.
- * @returns `true` if the input is "true", `false` if the input is "false", or the original string otherwise.
- */
-export function stringToBoolean(string: string): boolean | string {
-  if (string.toLowerCase() === "true") {
-    return true;
+/** @throws */
+export function validateSync(schema: SchemaType, value?: unknown): SchemaResult {
+  const results = schema["~standard"].validate(value);
+  if (results instanceof Promise) {
+    throw new TypeError("async schema validation not supported");
   }
 
-  if (string.toLowerCase() === "false") {
-    return false;
+  return results;
+}
+
+export function defaultValueAndIsOptional(schema: SchemaType): { defaultValue: unknown; optional: boolean } {
+  const results = validateSync(schema);
+
+  if (results.issues) {
+    return { defaultValue: undefined, optional: false };
+  }
+
+  return { defaultValue: results.value, optional: true };
+}
+
+export function PrepareType(schema: SchemaType, coerceHandler: CoerceMethod<unknown>): PreparedType {
+  const { optional, defaultValue } = defaultValueAndIsOptional(schema);
+
+  return {
+    schema,
+    optional,
+    defaultValue,
+    coerceTo: coerceHandler.type,
+    validate: (value?: string) => validateSync(schema, value && coerceHandler(value)),
+  };
+}
+
+export function prepareDefinitionTypes(definition: Record<string, Argument> | Record<string, Option> | undefined) {
+  if (!definition) return;
+
+  for (const object of Object.values<Argument | Option>(definition)) {
+    if (!object.coerce) {
+      object.coerce = (value: string) => value;
+    }
+
+    if (!object._preparedType) {
+      object._preparedType = PrepareType(object.schema, object.coerce);
+    }
   }
+}
 
-  return string;
+export function toKebabCase(input: string): string {
+  return input.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 
 /**
@@ -68,10 +103,9 @@ export function indent(count: number) {
   return " ".repeat(count);
 }
 
-/** Concat strings */
-export function concat(...messages: string[]) {
-  // messages = messages.filter(Boolean);
-  return messages.join(" ");
+/** Indents every line in the given text by the provided number of spaces. Empty lines are preserved. */
+export function indentLines(text: string, spaces: number): string {
+  return text.replace(/\n/g, "\n" + indent(spaces));
 }
 
 export function stringifyValue(value: unknown): string {
@@ -93,7 +127,7 @@ export function stringifyValue(value: unknown): string {
 /** Insert text at the end of the first line */
 export function insertAtEndOfFirstLine(string: string, insert: string) {
   const lines = string.split("\n");
-  lines[0] += " " + insert;
+  lines[0] += (lines[0] ? " " : "") + insert;
   return lines.join("\n");
 }
 
@@ -101,15 +135,19 @@ export function insertAtEndOfFirstLine(string: string, insert: string) {
 export function subcommandPlaceholder(metadata: SubcommandMetadata): string {
   let placeholder = metadata.placeholder;
 
-  if (!placeholder && metadata.options.length > 0) {
-    placeholder = "[options]";
+  if (placeholder) {
+    return placeholder;
   }
 
-  if (!placeholder && metadata.arguments.length > 0) {
-    placeholder = "<arguments>";
+  if (metadata.options.length > 0) {
+    placeholder += (placeholder ? " " : "") + "[options]";
   }
 
-  if (metadata.allowPositional) {
+  if (metadata.arguments.length > 0) {
+    placeholder += (placeholder ? " " : "") + "<arguments>";
+  }
+
+  if (metadata.allowPositionals) {
     placeholder += (placeholder ? " " : "") + "<positionals>";
   }
 
@@ -119,3 +157,142 @@ export function subcommandPlaceholder(metadata: SubcommandMetadata): string {
 
   return placeholder;
 }
+
+/** Parse a string into an argv (array of arguments) */
+export function parseArgv(input: string): string[] {
+  const argv = [];
+
+  let currentQuote: string | undefined = undefined;
+  let currentArgument: string | undefined = undefined;
+
+  for (let index = 0; index < input.length; index++) {
+    const char = input[index];
+    const previousChar = input[index - 1];
+    const nextChar = input[index + 1];
+    const end = index === input.length - 1;
+
+    // entering/leaving quote
+    if ((char === '"' || char === "'") && previousChar !== "\\") {
+      // leaving quote
+      if (currentQuote === char) {
+        currentQuote = undefined;
+        continue;
+      }
+
+      // entering quote
+      if (currentQuote === undefined) {
+        currentQuote = char;
+        continue;
+      }
+
+      // quote inside quote
+      if (currentQuote !== undefined && char !== currentQuote) {
+        currentArgument += char;
+        continue;
+      }
+      continue;
+    }
+
+    // new line
+    if (char === "\\" && nextChar === "\n") {
+      index++;
+      continue;
+    }
+
+    // Add to argv
+    if (currentArgument !== undefined && currentQuote === undefined) {
+      if (char === " ") {
+        argv.push(currentArgument);
+        currentArgument = undefined;
+        continue;
+      }
+
+      if (end) {
+        currentArgument += char;
+        argv.push(currentArgument);
+        currentArgument = undefined;
+        continue;
+      }
+    }
+
+    // Ignore spaces outside of quotes
+    if (char === " " && currentQuote === undefined) {
+      continue;
+    }
+
+    // Ignore escaped characters
+    if (char === "\\" && (nextChar === "'" || nextChar === '"')) {
+      continue;
+    }
+
+    currentArgument ??= "";
+    currentArgument += char;
+  }
+
+  // Add last argument
+  if (currentArgument !== undefined) {
+    argv.push(currentArgument);
+  }
+
+  return argv;
+}
+
+/**
+ * Escape HTML characters inside HTML tags in a Markdown string, but leave code blocks, inline code, and HTML comments
+ * unchanged.
+ */
+export function escapeHtmlTags(markdown: string): string {
+  const escapeMap: Record<string, string> = { "&": "&amp;", "<": "&lt;", ">": "&gt;" };
+
+  // Captures:
+  // 1) fenced code blocks or inline code
+  // 2) HTML comments <!-- ... -->
+  // 3) other HTML tags like <b>, <div attr="x">, etc.
+  const re = /(```[\s\S]*?```|`[^`]*`)|(<!--[\s\S]*?-->)|(<[^>]+>)/g;
+
+  return markdown.replace(re, (fullMatch: string, code?: string, comment?: string, tag?: string) => {
+    if (code) return code;
+    if (comment) return comment;
+    if (!tag) return fullMatch;
+
+    return tag.replace(/[&<>]/g, ch => escapeMap[ch]);
+  });
+}
+
+/** Credits: https://github.com/chalk/ansi-regex */
+function ansiRegex({ onlyFirst = false } = {}) {
+  // Valid string terminator sequences are BEL, ESC\, and 0x9c
+  const ST = String.raw`(?:\u0007|\u001B\u005C|\u009C)`;
+
+  // OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
+  const osc = String.raw`(?:\u001B\][\s\S]*?${ST})`;
+
+  // CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
+  const csi = String.raw`[\u001B\u009B][[\]()#;?]*(?:\d{1,4}(?:[;:]\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]`;
+
+  const pattern = `${osc}|${csi}`;
+
+  return new RegExp(pattern, onlyFirst ? undefined : "g");
+}
+
+const regex = ansiRegex();
+
+export function stripAnsi(string: string): string {
+  return string.replace(regex, "");
+}
+
+export function findDuplicateStrings(values: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const duplicates = new Set<string>();
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      duplicates.add(value);
+      continue;
+    }
+
+    seen.add(value);
+  }
+
+  return Array.from(duplicates);
+}

package/lib/commonjs/autocomplete-scripts/bash-autocomplete-script.cjs

@@ -1,42 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:true});exports.generateBashAutocompleteScript=generateBashAutocompleteScript;var _parserHelpers=require("../parser/parse/parser-helpers.cjs");function generateBashAutocompleteScript(...parameters){const[cli,...subcommands]=parameters;const mappedCommands={};for(const subcommand of subcommands){mappedCommands[subcommand.name]={options:subcommand.options?.map(option=>(0,_parserHelpers.transformOptionToArgument)(option.name))??[],aliases:subcommand.aliases??[]}}let switchCase="";for(const[key,{options,aliases}]of Object.entries(mappedCommands)){switchCase+=`    ${key}${aliases.length>0?"|":""}${aliases.join("|")})\n`;switchCase+=`      opts="${options.join(" ")}"\n`;switchCase+="      ;;\n"}if(cli.options?.length){switchCase+=`    "-"*)\n`;switchCase+=`      opts="${cli.options.map(option=>(0,_parserHelpers.transformOptionToArgument)(option.name)).join(" ")}"\n`;switchCase+="      ;;\n"}return`# Auto-generated by zod-args-parser
-
-_${cli.cliName}_autocomplete() {
-  local cur prev commands opts subcommand used_opts filtered_opts
-
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  subcommand="\${COMP_WORDS[1]}"
-
-  commands="${Object.keys(mappedCommands).join(" ")}"
-
-  case "$subcommand" in
-${switchCase}
-  esac
-
-  used_opts=""
-  if [[ " \${commands[@]} " =~ " $subcommand " ]]; then
-    for word in "\${COMP_WORDS[@]:2}"; do
-      if [[ "$word" =~ ^- ]]; then
-        used_opts+=" $word"
-      fi
-    done
-  fi
-
-  if [[ -n "$opts" ]]; then
-    filtered_opts=""
-    for opt in $opts; do
-      if [[ ! " $used_opts " =~ " $opt " ]]; then
-        filtered_opts+="$opt "
-      fi
-    done
-    COMPREPLY=( $(compgen -W "$filtered_opts" -- "$cur") )
-    return
-  fi
-
-  if [[ "\${COMP_CWORD}" -eq 1 ]]; then
-    COMPREPLY=( $(compgen -W "$commands" -- "$cur") )
-  fi
-}
-
-complete -F _${cli.cliName}_autocomplete ${cli.cliName}
-`}

package/lib/commonjs/autocomplete-scripts/bash-autocomplete-script.cjs.map

@@ -1 +0,0 @@
-{"version":3,"names":["_parserHelpers","require","generateBashAutocompleteScript","parameters","cli","subcommands","mappedCommands","subcommand","name","options","map","option","transformOptionToArgument","aliases","switchCase","key","Object","entries","length","join","cliName","keys"],"sourceRoot":"../../../src/autocomplete-scripts","sources":["bash-autocomplete-script.ts"],"sourcesContent":["import { transformOptionToArgument } from \"../parser/parse/parser-helpers.js\";\n\nimport type { Cli, Subcommand } from \"../types.js\";\n\n/**\n * - Generate bash autocomplete script for your CLI\n * - The generated script should be added to your `.bash_profile` or `.bashrc` file:\n *\n *   - Run: `nano $HOME/.bash_profile` or `nano $HOME/.bashrc`\n *   - Add the following line: `source <generated script path>`\n *   - Save and reopen bash to take effect\n */\nexport function generateBashAutocompleteScript(...parameters: [Cli, ...Subcommand[]]): string {\n  const [cli, ...subcommands] = parameters;\n\n  type MappedCommands = Record<string, { options: string[]; aliases: string[] }>;\n\n  const mappedCommands: MappedCommands = {};\n  for (const subcommand of subcommands) {\n    mappedCommands[subcommand.name] = {\n      options: subcommand.options?.map(option => transformOptionToArgument(option.name)) ?? [],\n      aliases: subcommand.aliases ?? [],\n    };\n  }\n\n  let switchCase = \"\";\n  for (const [key, { options, aliases }] of Object.entries(mappedCommands)) {\n    switchCase += `    ${key}${aliases.length > 0 ? \"|\" : \"\"}${aliases.join(\"|\")})\\n`;\n    switchCase += `      opts=\"${options.join(\" \")}\"\\n`;\n    switchCase += \"      ;;\\n\";\n  }\n\n  if (cli.options?.length) {\n    switchCase += `    \"-\"*)\\n`;\n    switchCase += `      opts=\"${cli.options.map(option => transformOptionToArgument(option.name)).join(\" \")}\"\\n`;\n    switchCase += \"      ;;\\n\";\n  }\n\n  return `# Auto-generated by zod-args-parser\n\n_${cli.cliName}_autocomplete() {\n  local cur prev commands opts subcommand used_opts filtered_opts\n\n  cur=\"\\${COMP_WORDS[COMP_CWORD]}\"\n  prev=\"\\${COMP_WORDS[COMP_CWORD-1]}\"\n  subcommand=\"\\${COMP_WORDS[1]}\"\n\n  commands=\"${Object.keys(mappedCommands).join(\" \")}\"\n\n  case \"$subcommand\" in\n${switchCase}\n  esac\n\n  used_opts=\"\"\n  if [[ \" \\${commands[@]} \" =~ \" $subcommand \" ]]; then\n    for word in \"\\${COMP_WORDS[@]:2}\"; do\n      if [[ \"$word\" =~ ^- ]]; then\n        used_opts+=\" $word\"\n      fi\n    done\n  fi\n\n  if [[ -n \"$opts\" ]]; then\n    filtered_opts=\"\"\n    for opt in $opts; do\n      if [[ ! \" $used_opts \" =~ \" $opt \" ]]; then\n        filtered_opts+=\"$opt \"\n      fi\n    done\n    COMPREPLY=( $(compgen -W \"$filtered_opts\" -- \"$cur\") )\n    return\n  fi\n\n  if [[ \"\\${COMP_CWORD}\" -eq 1 ]]; then\n    COMPREPLY=( $(compgen -W \"$commands\" -- \"$cur\") )\n  fi\n}\n\ncomplete -F _${cli.cliName}_autocomplete ${cli.cliName}\n`;\n}\n"],"mappings":"4IAAA,IAAAA,cAAA,CAAAC,OAAA,uCAYO,QAAS,CAAAC,8BAA8BA,CAAC,GAAGC,UAAkC,CAAU,CAC5F,KAAM,CAACC,GAAG,CAAE,GAAGC,WAAW,CAAC,CAAGF,UAAU,CAIxC,KAAM,CAAAG,cAA8B,CAAG,CAAC,CAAC,CACzC,IAAK,KAAM,CAAAC,UAAU,GAAI,CAAAF,WAAW,CAAE,CACpCC,cAAc,CAACC,UAAU,CAACC,IAAI,CAAC,CAAG,CAChCC,OAAO,CAAEF,UAAU,CAACE,OAAO,EAAEC,GAAG,CAACC,MAAM,EAAI,GAAAC,wCAAyB,EAACD,MAAM,CAACH,IAAI,CAAC,CAAC,EAAI,EAAE,CACxFK,OAAO,CAAEN,UAAU,CAACM,OAAO,EAAI,EACjC,CACF,CAEA,GAAI,CAAAC,UAAU,CAAG,EAAE,CACnB,IAAK,KAAM,CAACC,GAAG,CAAE,CAAEN,OAAO,CAAEI,OAAQ,CAAC,CAAC,EAAI,CAAAG,MAAM,CAACC,OAAO,CAACX,cAAc,CAAC,CAAE,CACxEQ,UAAU,EAAI,OAAOC,GAAG,GAAGF,OAAO,CAACK,MAAM,CAAG,CAAC,CAAG,GAAG,CAAG,EAAE,GAAGL,OAAO,CAACM,IAAI,CAAC,GAAG,CAAC,KAAK,CACjFL,UAAU,EAAI,eAAeL,OAAO,CAACU,IAAI,CAAC,GAAG,CAAC,KAAK,CACnDL,UAAU,EAAI,YAChB,CAEA,GAAIV,GAAG,CAACK,OAAO,EAAES,MAAM,CAAE,CACvBJ,UAAU,EAAI,aAAa,CAC3BA,UAAU,EAAI,eAAeV,GAAG,CAACK,OAAO,CAACC,GAAG,CAACC,MAAM,EAAI,GAAAC,wCAAyB,EAACD,MAAM,CAACH,IAAI,CAAC,CAAC,CAACW,IAAI,CAAC,GAAG,CAAC,KAAK,CAC7GL,UAAU,EAAI,YAChB,CAEA,MAAO;AACT;AACA,GAAGV,GAAG,CAACgB,OAAO;AACd;AACA;AACA;AACA;AACA;AACA;AACA,cAAcJ,MAAM,CAACK,IAAI,CAACf,cAAc,CAAC,CAACa,IAAI,CAAC,GAAG,CAAC;AACnD;AACA;AACA,EAAEL,UAAU;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAeV,GAAG,CAACgB,OAAO,iBAAiBhB,GAAG,CAACgB,OAAO;AACtD,CACA","ignoreList":[]}