zod-args-parser 2.0.0-beta.1 → 2.0.0-beta.3

package/lib/types/utilities/schema-utilities.d.ts

@@ -0,0 +1,15 @@
+import type { Argument, Option } from "../types/definitions-types.ts";
+import type { SchemaResult, SchemaType } from "../types/schema-types.ts";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+/** @throws {CliError} When schema is async */
+export declare function validateSync(schema: SchemaType, value?: unknown): SchemaResult;
+/** @throws {CliError} When schema is async */
+export declare function defaultValueAndIsOptional(schema: SchemaType): {
+    defaultValue: unknown;
+    optional: boolean;
+};
+/** @throws {CliError} When schema is async */
+export declare function prepareDefinitionTypes(definition: Record<string, Argument> | Record<string, Option> | undefined): void;
+/** Prettify Standard Schema V1 issues */
+export declare function prettifyError(issues: ReadonlyArray<StandardSchemaV1.Issue>): string;
+//# sourceMappingURL=schema-utilities.d.ts.map

package/lib/types/utilities/schema-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-utilities.d.ts","sourceRoot":"","sources":["../../../src/utilities/schema-utilities.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAgB,MAAM,+BAA+B,CAAC;AACpF,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,YAAY,CAW9E;AAED,8CAA8C;AAC9C,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,UAAU,GAAG;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAQ1G;AAeD,8CAA8C;AAC9C,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,QAY/G;AAED,yCAAyC;AACzC,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,MAAM,CAQnF"}

package/lib/{typescript → types/utilities}/utilities.d.ts

@@ -1,15 +1,4 @@
-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";
-/** @throws */
-export declare function validateSync(schema: SchemaType, value?: unknown): SchemaResult;
-export declare function defaultValueAndIsOptional(schema: SchemaType): {
-    defaultValue: unknown;
-    optional: boolean;
-};
-export declare function PrepareType(schema: SchemaType, coerceHandler: CoerceMethod<unknown>): PreparedType;
-export declare function prepareDefinitionTypes(definition: Record<string, Argument> | Record<string, Option> | undefined): void;
+import type { SubcommandMetadata } from "../types/metadata-types.ts";
 export declare function toKebabCase(input: string): string;
 /**
  * Converts a zero-based index into its human-readable ordinal form.
@@ -33,13 +22,21 @@ export declare function stringifyValue(value: unknown): string;
 export declare function insertAtEndOfFirstLine(string: string, insert: string): string;
 /** Get the placeholder for a subcommand */
 export declare function subcommandPlaceholder(metadata: SubcommandMetadata): string;
-/** Parse a string into an argv (array of arguments) */
-export declare function parseArgv(input: string): string[];
 /**
  * Escape HTML characters inside HTML tags in a Markdown string, but leave code blocks, inline code, and HTML comments
  * unchanged.
  */
 export declare function escapeHtmlTags(markdown: string): string;
 export declare function stripAnsi(string: string): string;
-export declare function findDuplicateStrings(values: readonly string[]): string[];
+type WalkCallback = (key: string, value: unknown, path: string) => unknown;
+/**
+ * Recursively walks through an object and calls a function for each key-value pair.
+ *
+ * @param object_ - The object to walk.
+ * @param onVisit - Function called on every visited property (key, value, path).
+ * @param basePath - (Internal) Used for recursion to build nested paths.
+ */
+export declare function walkObject(object_: Record<string, unknown>, onVisit: WalkCallback, basePath?: string): void;
+export declare function Enum<const T extends Record<string, undefined>>(value: T): { [K in keyof T]: K; };
+export {};
 //# sourceMappingURL=utilities.d.ts.map

package/lib/types/utilities/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../../src/utilities/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA2B3D;AAED,eAAe;AACf,wBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,UAE/B;AAED,YAAY;AACZ,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,UAGnC;AAED,wGAAwG;AACxG,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAcrD;AAED,+CAA+C;AAC/C,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAIpE;AAED,2CAA2C;AAC3C,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAwB1E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBvD;AAoBD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;AAE3E;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,QAAQ,SAAK,GAAG,IAAI,CAcvG;AAED,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,GAGtC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAE,CACtD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-args-parser",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "description": "A TypeScript-first CLI argument parser with schema-based validation.",
   "author": "Ahmed ALABSI <alabsi91@gmail.com>",
   "license": "MIT",
@@ -9,22 +9,23 @@
     "url": "https://github.com/alabsi91/zod-args-parser.git"
   },
   "type": "module",
+  "sideEffects": false,
   "scripts": {
     "dev": "tsx --watch example/index.ts",
     "build": "node scripts/build.ts",
     "test": "node --test && echo Checking types... && tsgo --noEmit && echo Linting... && eslint --config eslint.config.js --fix",
     "prepare": "npm run test && npm run build"
   },
+  "jsdelivr": "./lib/iife/index.js",
+  "unpkg": "./lib/iife/index.js",
   "exports": {
     ".": {
-      "types": "./lib/typescript/index.d.ts",
+      "types": "./lib/types/index.d.ts",
       "browser": "./lib/esm/index.js",
-      "import": "./lib/mjs/index.mjs",
-      "require": "./lib/cjs/index.cjs"
+      "node": "./lib/mjs/index.mjs",
+      "default": "./lib/esm/index.js"
     }
   },
-  "jsdelivr": "./lib/iife/index.js",
-  "unpkg": "./lib/iife/index.js",
   "files": [
     "lib",
     "src"
@@ -43,7 +44,7 @@
     "@eslint/js": "^9.39.1",
     "@eslint/markdown": "^7.5.1",
     "@trivago/prettier-plugin-sort-imports": "^6.0.0",
-    "@types/node": "^24.10.0",
+    "@types/node": "^24.10.1",
     "@typescript/native-preview": "^7.0.0-dev.20251104.1",
     "esbuild": "^0.27.0",
     "eslint": "^9.39.1",
@@ -60,8 +61,8 @@
     "zod": "^4.1.12"
   },
   "dependencies": {
-    "@standard-schema/spec": "^1.0.0",
     "chalk": "^5.6.2",
-    "marked": "^17.0.0"
+    "marked": "^17.0.0",
+    "@standard-schema/spec": "^1.0.0"
   }
 }

package/src/autocomplete-scripts/bash-autocomplete-script.ts

@@ -12,11 +12,10 @@ import type { Cli } from "../types/definitions-types.ts";
  */
 export function generateBashAutocompleteScript(cliDefinition: Cli): string {
   const subcommands = cliDefinition.subcommands ?? [];
-
   type MappedCommands = Record<string, { options: string[]; aliases: string[] }>;
 
+  // Map subcommands to options + aliases
   const mappedCommands: MappedCommands = {};
-
   for (const subcommand of subcommands) {
     mappedCommands[subcommand.name] = {
       options: subcommand.options ? Object.keys(subcommand.options).map(key => transformOptionToArgument(key)) : [],
@@ -24,19 +23,23 @@ export function generateBashAutocompleteScript(cliDefinition: Cli): string {
     };
   }
 
+  // Generate switch-case block for subcommands + aliases
   let switchCase = "";
-  for (const [key, { options, aliases }] of Object.entries(mappedCommands)) {
-    switchCase += `    ${key}${aliases.length > 0 ? "|" : ""}${aliases.join("|")})\n`;
+  for (const [name, { options, aliases }] of Object.entries(mappedCommands)) {
+    const caseNames = [name, ...aliases];
+    switchCase += `    ${caseNames.join("|")})\n`;
     switchCase += `      opts="${options.join(" ")}"\n`;
     switchCase += "      ;;\n";
   }
 
-  if (cliDefinition.options?.length) {
-    const optionsNames = cliDefinition.options
-      ? Object.keys(cliDefinition.options).map(key => transformOptionToArgument(key))
-      : [];
-    switchCase += `    "-"*)\n`;
-    switchCase += `      opts="${optionsNames.join(" ")}"\n`;
+  // Include global CLI options in a default case
+  const globalOptions = cliDefinition.options
+    ? Object.keys(cliDefinition.options).map(key => transformOptionToArgument(key))
+    : [];
+
+  if (globalOptions.length > 0) {
+    switchCase += `    *)\n`;
+    switchCase += `      opts="${globalOptions.join(" ")}"\n`;
     switchCase += "      ;;\n";
   }
 
@@ -52,8 +55,7 @@ _${cliDefinition.cliName}_autocomplete() {
   commands="${Object.keys(mappedCommands).join(" ")}"
 
   case "$subcommand" in
-${switchCase}
-  esac
+${switchCase}  esac
 
   used_opts=""
   if [[ " \${commands[@]} " =~ " $subcommand " ]]; then

package/src/autocomplete-scripts/powershell-autocomplete-script.ts

@@ -3,83 +3,117 @@ import { transformOptionToArgument } from "../parse/parser-utilities.ts";
 import type { Cli } from "../types/definitions-types.ts";
 
 /**
- * - Generates a PowerShell autocomplete script for your CLI.
- * - The script assumes that your CLI is available as a `.ps1` file in the environment variable. For example:
- *   `cliName.ps1`.
- * - This should return a path to your script: `(Get-Command <cliName>.ps1).Source`
- * - The generated script should be added to your `profile.ps1` file:
+ * Generates a PowerShell autocomplete script for a CLI.
  *
- *   - Run: `notepad $profile`
- *   - Add the following line: `. "<generated script path>"`
- *   - Save and reopen powershell to take effect
+ * Instructions:
+ *
+ * - Ensure your CLI is available as a `.ps1` file in your environment. e.g., `cliName.ps1`.
+ * - Add the generated script to your `profile.ps1` file:
+ *
+ *   1. Run: `notepad $profile`
+ *   2. Add: `. "<generated script path>"`
+ *   3. Save and reopen PowerShell
  */
 export function generatePowerShellAutocompleteScript(cliDefinition: Cli): string {
   const subcommands = cliDefinition.subcommands ?? [];
   const meta = cliDefinition.meta ?? {};
 
-  type MappedCommands = Record<string, { options: string[]; aliases: string[] }>;
+  interface CommandData {
+    options: string[];
+    aliases: string[];
+  }
 
-  const mappedCommands: MappedCommands = {};
+  const mappedCommands: Record<string, CommandData> = {};
 
+  // Map subcommands to their options and aliases
   for (const subcommand of subcommands) {
-    mappedCommands[subcommand.name] = {
-      options: subcommand.options ? Object.keys(subcommand.options).map(key => transformOptionToArgument(key)) : [],
-      aliases: subcommand.aliases ?? [],
-    };
+    const options: string[] = [];
+    if (subcommand.options) {
+      for (const key of Object.keys(subcommand.options)) {
+        options.push(transformOptionToArgument(key));
+      }
+    }
+
+    const aliases: string[] = subcommand.aliases ?? [];
+    mappedCommands[subcommand.name] = { options, aliases };
   }
 
+  // Prepare string representations for subcommands and CLI global options
   const subcommandsString = Object.keys(mappedCommands)
     .map(key => `'${key}'`)
     .join(", ");
 
-  const optionsNames = cliDefinition.options
-    ? Object.keys(cliDefinition.options).map(key => transformOptionToArgument(key))
-    : [];
-  const cliOptionsString = optionsNames.map(option => `'${option}'`).join(", ");
+  const cliOptions: string[] = [];
+  if (cliDefinition.options) {
+    for (const key of Object.keys(cliDefinition.options)) {
+      cliOptions.push(transformOptionToArgument(key));
+    }
+  }
+
+  const cliOptionsString = cliOptions.map(opt => `'${opt}'`).join(", ");
 
+  // Build the switch-case mapping subcommands/aliases to their options
   let switchCase = "switch ($subcommand) {\n";
-  for (const [key, { options, aliases }] of Object.entries(mappedCommands)) {
-    const optionsString = options.map(option => `'${option}'`).join(", ");
-    switchCase += `        '${key}' { @(${optionsString}) }\n`;
-    for (const a of aliases) {
-      switchCase += `        '${a}' { @(${optionsString}) }\n`;
+  for (const commandName in mappedCommands) {
+    const data = mappedCommands[commandName];
+    const optionsString = data.options.map(opt => `'${opt}'`).join(", ");
+
+    // Primary subcommand
+    switchCase += `        '${commandName}' { @(${optionsString}) }\n`;
+
+    // Aliases
+    for (const alias of data.aliases) {
+      switchCase += `        '${alias}' { @(${optionsString}) }\n`;
     }
   }
+
+  // Default case returns global CLI options
   switchCase += `        default { @(${cliOptionsString}) }\n    }`;
 
-  const description = meta.description ?? meta.descriptionMarkdown;
+  // Optional comment block with description/example
+  let commentBlock = "";
+  if (meta.description || meta.example) {
+    commentBlock = "<#\n";
+
+    if (meta.description || meta.descriptionMarkdown) {
+      commentBlock += `.DESCRIPTION\n${meta.description ?? meta.descriptionMarkdown}\n\n`;
+    }
+
+    if (meta.example) {
+      commentBlock += `.EXAMPLE\n${meta.example}\n`;
+    }
 
-  let functionInfo = "";
-  if (description) {
-    functionInfo = `<#\n.DESCRIPTION\n${description}\n${meta.example ? `\n.EXAMPLE\n${meta.example}` : ""}\n#>`;
+    commentBlock += "#>";
   }
 
+  const cliName = cliDefinition.cliName;
+
   return `# Auto-generated by zod-args-parser
 
-${functionInfo}
-function ${cliDefinition.cliName} {
+${commentBlock}
+function ${cliName} {
     param(
         [Parameter(Position = 0, Mandatory = $false)]
         [string]$subcommand,
         [Parameter(Position = 1, ValueFromRemainingArguments = $true)]
         [string[]]$arguments
     )
-    $scriptPath = (Get-Command '${cliDefinition.cliName}.ps1').Source
+    $scriptPath = (Get-Command '${cliName}.ps1').Source
     if ($scriptPath) {
         $argumentList = @($subcommand) + ($arguments | Where-Object { $_ -notin '--', '--%' }) | Where-Object { $_ -ne '' }
         & $scriptPath @argumentList
         return
     }
-    Write-Error "Could not find '${cliDefinition.cliName}.ps1' script"
+    Write-Error "Could not find '${cliName}.ps1' script"
 }
 
-Register-ArgumentCompleter -CommandName '${cliDefinition.cliName}' -ParameterName 'subcommand' -ScriptBlock {
+Register-ArgumentCompleter -CommandName '${cliName}' -ParameterName 'subcommand' -ScriptBlock {
     param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
     $subcommands = @(${subcommandsString}${subcommandsString && cliOptionsString ? ", " : ""}${cliOptionsString})
     $subcommands | Where-Object { $_ -like "$wordToComplete*" }
 }
 
-Register-ArgumentCompleter -CommandName '${cliDefinition.cliName}' -ParameterName 'arguments' -ScriptBlock {
+Register-ArgumentCompleter -CommandName '${cliName}' -ParameterName 'arguments' -ScriptBlock {
     param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
     $subcommand = $commandAst.CommandElements[1].Value
     $arguments = ${switchCase}

package/src/autocomplete-scripts/zsh-autocomplete-script.ts

@@ -2,58 +2,66 @@ import { transformOptionToArgument } from "../parse/parser-utilities.ts";
 
 import type { Cli, Subcommand } from "../types/definitions-types.ts";
 
-/**
- * - Generates a ZSH autocomplete script for your CLI.
- * - The generated script should be added to your `~/.zshrc` or `~/.zsh_profile` file:
- *
- *   - Run: `nano $HOME/.zshrc` or `nano $HOME/.zsh_profile`
- *   - Add the following line: `source <generated script path>`
- *   - Save and reopen zsh to take effect
- */
+/** Generates a Zsh autocomplete script for a CLI, including global options when no subcommand is provided. */
 export function generateZshAutocompleteScript(cliDefinition: Cli): string {
   const subcommands = cliDefinition.subcommands ?? [];
 
-  const genArguments = (command: Subcommand) => {
-    const optionsNameDesc = command.options
-      ? Object.entries(command.options).map(
-          ([name, value]) => `'${transformOptionToArgument(name)}[${value.meta?.description ?? ""}]'`,
-        )
-      : [];
-
-    return optionsNameDesc.join(" \\\n            ");
+  /** Generate the argument strings for a subcommand Format: 'option[description]' */
+  const generateArguments = (command: Subcommand) => {
+    if (!command.options) return "";
+    const arguments_ = Object.entries(command.options).map(([name, option]) => {
+      const description = option.meta?.description ?? "";
+      return `'${transformOptionToArgument(name)}[${description}]'`;
+    });
+    return arguments_.join(" \\\n            ");
   };
 
-  const genSubCommand = (subcommand: Subcommand) => {
-    const options = subcommand.options;
-    if (!options) return "";
+  /** Generate a case block for a subcommand */
+  const generateSubcommandCase = (subcommand: Subcommand) => {
     return String.raw`${subcommand.name})
           _arguments \
-            ${genArguments(subcommand)} \
+            ${generateArguments(subcommand)} \
             '*: :_files' \
             && ret=0
           ;;`;
   };
 
+  const subcommandCases = subcommands
+    .map(cmd => generateSubcommandCase(cmd))
+    .filter(Boolean)
+    .join("\n        ");
+
+  const commandDescriptions = subcommands.map(sub => `"${sub.name}:${sub.meta?.description ?? ""}"`).join("\n    ");
+
+  // Global CLI options (only used when no subcommand is provided)
+  const globalOptions = cliDefinition.options
+    ? Object.entries(cliDefinition.options)
+        .map(([name, option]) => {
+          const description = option.meta?.description ?? "";
+          return `'${transformOptionToArgument(name)}[${description}]'`;
+        })
+        .join(" \\\n            ")
+    : "";
+
+  const cliName = cliDefinition.cliName;
+
   return String.raw`# Auto-generated by zod-args-parser
 
-_${cliDefinition.cliName}_autocomplete() {
+_${cliName}_autocomplete() {
   local ret=1
 
   _arguments -C \
-    '1: :_${cliDefinition.cliName}_commands' \
+    '1: :_${cliName}_commands' \
     '*:: :->subcmds' \
     && ret=0
 
   case $state in
     subcmds)
       case "$words[1]" in
-        ${subcommands
-          .map(subCommand => genSubCommand(subCommand))
-          .filter(Boolean)
-          .join("\n        ")}
+        ${subcommandCases}
         *)
           _arguments \
-            '*: :_files' \
+            ${globalOptions ? globalOptions + " \\\n            " : ""}'*: :_files' \
             && ret=0
           ;;
       esac
@@ -62,15 +70,15 @@ _${cliDefinition.cliName}_autocomplete() {
 
   return $ret
 }
-  
-_${cliDefinition.cliName}_commands() {
+
+_${cliName}_commands() {
   local -a commands=(
-    ${subcommands.map(subcommand => `"${subcommand.name}:${subcommand.meta?.description ?? ""}"`).join("\n    ")}
+    ${commandDescriptions}
   )
 
   _describe -t subcommands 'subcommand' commands
 }
 
-compdef _${cliDefinition.cliName}_autocomplete ${cliDefinition.cliName}
+compdef _${cliName}_autocomplete ${cliName}
 `;
 }

package/src/cli-error/cli-error.ts

@@ -0,0 +1,44 @@
+import { ErrorCause } from "./error-cause.ts";
+import { definitionErrorMessage } from "./error-message/definition-error-message.ts";
+import { internalErrorMessage } from "./error-message/internal-error-message.ts";
+import { parseErrorMessage } from "./error-message/parse-error-message.ts";
+import { validationErrorMessage } from "./error-message/validation-error-message.ts";
+
+import type { CliErrorImpl, CliErrorOptionUnion } from "../types/error-types.ts";
+
+export class CliError extends Error implements CliErrorImpl {
+  readonly code;
+  readonly cause;
+  readonly context;
+
+  constructor(options: CliErrorOptionUnion) {
+    super(options.message ?? CliError.errorMessage(options));
+
+    this.cause = options.cause;
+    this.code = options.code;
+    this.context = options.context;
+  }
+
+  static errorMessage(options: CliErrorOptionUnion): string {
+    const defaultErrorMessage = "unknown error";
+
+    if (options.cause === ErrorCause.Internal) {
+      return internalErrorMessage(options) ?? defaultErrorMessage;
+    }
+
+    if (options.cause === ErrorCause.Parse) {
+      return parseErrorMessage(options) ?? defaultErrorMessage;
+    }
+
+    if (options.cause === ErrorCause.Definition) {
+      return definitionErrorMessage(options) ?? defaultErrorMessage;
+    }
+
+    if (options.cause === ErrorCause.Validation) {
+      return validationErrorMessage(options) ?? defaultErrorMessage;
+    }
+
+    const executiveCheck: never = options;
+    return executiveCheck;
+  }
+}

package/src/cli-error/error-cause.ts

@@ -0,0 +1,10 @@
+import { Enum } from "../utilities/utilities.ts";
+
+import type { ErrorCauseI } from "../types/error-types.ts";
+
+export const ErrorCause: { [K in keyof ErrorCauseI]: K } = Enum({
+  Internal: undefined,
+  Parse: undefined,
+  Validation: undefined,
+  Definition: undefined,
+});

package/src/cli-error/error-code/definition-error-code.ts

@@ -0,0 +1,21 @@
+import { Enum } from "../../utilities/utilities.ts";
+
+import type { DefinitionErrorI } from "../../types/error-types.ts";
+
+export const DefinitionErrorCode: { [K in keyof DefinitionErrorI]: K } = Enum({
+  MissingSchema: undefined,
+  EmptyDefinitionGroup: undefined,
+  MissingDefinitionName: undefined,
+  InvalidDefinitionOptionName: undefined,
+  InvalidDefinitionArgumentName: undefined,
+  InvalidOptionalArgumentDefinition: undefined,
+  DuplicateDefinitionName: undefined,
+  EmptyStringAliasName: undefined,
+  SelfRequire: undefined,
+  UnknownRequireName: undefined,
+  SelfConflict: undefined,
+  UnknownConflictName: undefined,
+  DefinitionRequiresConflictOverlap: undefined,
+  MissingOnExecute: undefined,
+  SubcommandHelpNotFound: undefined,
+});

package/src/cli-error/error-code/internal-error-code.ts

@@ -0,0 +1,8 @@
+import { Enum } from "../../utilities/utilities.ts";
+
+import type { InternalErrorI } from "../../types/error-types.ts";
+
+export const InternalErrorCode: { [K in keyof InternalErrorI]: K } = Enum({
+  MissingPreparedTypes: undefined,
+  CannotFindCliDefinition: undefined,
+});

package/src/cli-error/error-code/parse-error-code.ts

@@ -0,0 +1,16 @@
+import { Enum } from "../../utilities/utilities.ts";
+
+import type { ParseErrorI } from "../../types/error-types.ts";
+
+export const ParseErrorCode: { [K in keyof ParseErrorI]: K } = Enum({
+  UnknownSubcommand: undefined,
+  CommandWithoutOptions: undefined,
+  UnknownOption: undefined,
+  DuplicateOptionProvided: undefined,
+  InvalidNegationForNonBooleanOption: undefined,
+  PositionalArgumentNotAllowed: undefined,
+  MissingRequiredOption: undefined,
+  MissingRequiredArgument: undefined,
+  OptionMissingValue: undefined,
+  FlagAssignedValue: undefined,
+});

package/src/cli-error/error-code/validation-error-code.ts

@@ -0,0 +1,15 @@
+import { Enum } from "../../utilities/utilities.ts";
+
+import type { ValidationErrorI } from "../../types/error-types.ts";
+
+export const ValidationErrorCode: { [K in keyof ValidationErrorI]: K } = Enum({
+  NoOptionsToValidate: undefined,
+  NoArgumentsToValidate: undefined,
+  UnknownOptionValidation: undefined,
+  UnknownArgumentValidation: undefined,
+  SchemaValidationFailed: undefined,
+  MutuallyExclusiveConflict: undefined,
+  RequiredDependencyMissing: undefined,
+  AsyncSchemaNotSupported: undefined,
+  CoercionFailed: undefined,
+});