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

package/src/parser/validate/validate.ts

@@ -1,66 +0,0 @@
-import { prettifyError } from "zod/v4/core";
-
-import { generateOrdinalSuffix, stringToBoolean } from "../../utilities.js";
-import { isBooleanSchema, safeParseSchema } from "../../zod-utilities.js";
-
-import type { ParsedContext } from "../parse/parse-types.js";
-
-/** The return result object temporarily type. used inside the `parse` function */
-type ResultsTemporaryType = Record<string, unknown> & {
-  subcommand: string | undefined;
-  positional?: string[];
-  arguments?: unknown[];
-  ctx: ParsedContext;
-};
-
-export function validate(parsedData: ParsedContext) {
-  const results: ResultsTemporaryType = {
-    subcommand: parsedData.subcommand,
-    positional: parsedData.positional,
-    ctx: parsedData,
-  };
-
-  // validate options
-  for (const [optionName, { schema, rawValue, flag }] of Object.entries(parsedData.options)) {
-    let optionsValue: string | boolean | undefined = rawValue;
-
-    // infer boolean value if possible
-    if (flag && rawValue && isBooleanSchema(schema)) {
-      const booleanValue = stringToBoolean(rawValue);
-      if (typeof booleanValue === "boolean") {
-        const isNegated = flag.startsWith("--no");
-        optionsValue = isNegated ? !booleanValue : booleanValue;
-      }
-    }
-
-    const safeParseResult = safeParseSchema(schema, optionsValue);
-    if (!safeParseResult.success) {
-      throw new Error(`Invalid value "${rawValue}" for "${flag}": ${prettifyError(safeParseResult.error)}`, {
-        cause: "zod-args-parser",
-      });
-    }
-
-    results[optionName] = safeParseResult.data;
-  }
-
-  // validate arguments
-  if (parsedData.arguments) {
-    if (!results.arguments) results.arguments = [];
-
-    for (const { schema, rawValue } of parsedData.arguments) {
-      const argumentValue = rawValue && isBooleanSchema(schema) ? stringToBoolean(rawValue) : rawValue;
-
-      const safeParseResult = safeParseSchema(schema, argumentValue);
-      if (!safeParseResult.success) {
-        throw new Error(
-          `The ${generateOrdinalSuffix(results.arguments.length)} argument "${rawValue}" is invalid: ${prettifyError(safeParseResult.error)}`,
-          { cause: "zod-args-parser" },
-        );
-      }
-
-      results.arguments.push(safeParseResult.data);
-    }
-  }
-
-  return results;
-}

package/src/types.ts

@@ -1,365 +0,0 @@
-import type * as Z3 from "zod/v3";
-import type * as Z4 from "zod/v4/core";
-import type { ParseResult } from "./parser/parse/parse-types.js";
-import type { ValidateResult } from "./parser/validate/validate-type.js";
-
-export type SchemaV3 = Z3.ZodTypeAny;
-export type SchemaV4 = Z4.$ZodType;
-export type Schema = SchemaV3 | SchemaV4;
-
-export type ZodInferOutput<T extends Schema> = T extends SchemaV4
-  ? Z4.infer<T>
-  : T extends SchemaV3
-    ? Z3.infer<T>
-    : never;
-
-export type ZodInferInput<T extends Schema> = T extends SchemaV4
-  ? Z4.input<T>
-  : T extends SchemaV3
-    ? Z3.input<T>
-    : never;
-
-export interface Subcommand {
-  /**
-   * - The subcommand name
-   * - Make sure to not duplicate commands and aliases.
-   *
-   * @example
-   *   name: "test";
-   *   name: "run-app";
-   */
-  name: string;
-
-  /**
-   * - The description of the subcommand.
-   * - Used for generating the help message.
-   */
-  description?: string;
-
-  /** - The usage message in the help message. */
-  usage?: string;
-
-  /** - Used for generating the help message. */
-  placeholder?: string;
-
-  /**
-   * - Provide an example to show to the user.
-   * - Used for generating the help message.
-   */
-  example?: string;
-
-  /**
-   * - The aliases of the subcommand.
-   * - Make sure to not duplicate aliases and commands.
-   */
-  aliases?: string[];
-
-  /**
-   * - Allows positional arguments for this subcommand.
-   * - Unlike `arguments`, which are strictly typed, positional arguments are untyped and represented as a string array of
-   *   variable length.
-   * - When enabled and `arguments` are provided, `arguments` will be parsed first. Any remaining arguments will be
-   *   considered positional arguments and added to the `positional` property in the result.
-   */
-  allowPositional?: boolean;
-
-  /**
-   * - The options of the command.
-   * - Those options are specific to this subcommand.
-   */
-  options?: [Option, ...Option[]];
-
-  /**
-   * - Specifies a list of strictly typed arguments.
-   * - The order is important; for example, the first argument will be validated against the first specified type.
-   * - It is recommended to not use optional arguments as the parser will fill the arguments by order and can't determine
-   *   which arguments are optional.
-   */
-  arguments?: [Argument, ...Argument[]];
-
-  /**
-   * - The action is executed with the result of the parsed arguments.
-   * - To get typescript types use `setAction` instead of this.
-   *
-   * @example
-   *   const helpCommand = createSubcommand({ name: "help", options: [...] });
-   *   helpCommand.setAction(res => console.log(res));
-   */
-  action?: (data?: any) => any;
-
-  /**
-   * - The preValidation hook is executed before the action.
-   * - To get typescript types use `setPreValidationHook` instead of this.
-   *
-   * @example
-   *   const helpCommand = createSubcommand({ name: "help", options: [...] });
-   *   helpCommand.setPreValidationHook(ctx => console.log(ctx));
-   */
-  preValidation?: (context?: any) => any;
-}
-
-export type Cli = Prettify<
-  Omit<Subcommand, "name" | "aliases" | "placeholder"> & {
-    /** - The name of the CLI program. */
-    cliName: string;
-  }
->;
-
-export interface Option {
-  /**
-   * The name of the option, use a valid **JavaScript** variable name.\
-   * **Supports:** `camelCase`, `PascalCase`, `snake_case`, and `SCREAMING_SNAKE_CASE`.\
-   * **Examples:**
-   *
-   * - `I` or `i` ➡️ `-i`
-   * - `InputDir`, `inputDir`, or `INPUT_DIR` ➡️ `--input-dir`
-   * - `Help`, `help`, or `HELP` ➡️ `--help`
-   */
-  name: string;
-
-  /**
-   * - The will be used to validate the user input.
-   *
-   * @see https://zod.dev/api
-   */
-  type: Schema;
-
-  /**
-   * - The description of the option.
-   * - Used for generating the help message.
-   */
-  description?: string;
-
-  /** - Used for generating the help message. */
-  placeholder?: string;
-
-  /**
-   * - The example of using the option.
-   * - Used for generating the help message.
-   */
-  example?: string;
-
-  /**
-   * - The aliases of the option, use `CamelCase`.
-   * - Here you can specify short names or flags.
-   * - Make sure to not duplicate aliases.
-   */
-  aliases?: [string, ...string[]];
-}
-
-export interface Argument {
-  /** - The name of the argument. */
-  name: string;
-
-  /**
-   * - The will be used to validate the user input.
-   *
-   * @see https://zod.dev/api
-   */
-  type: Schema;
-
-  /**
-   * - The description of the argument.
-   * - Used for generating the help message.
-   */
-  description?: string;
-
-  /**
-   * - The example of using the argument.
-   * - Used for generating the help message.
-   */
-  example?: string;
-}
-
-export type ColorFunctionType = (...text: unknown[]) => string;
-
-/** - The colors to use for the help message. */
-export type HelpMessageStyle = Record<
-  | "title"
-  | "description"
-  | "default"
-  | "optional"
-  | "exampleTitle"
-  | "example"
-  | "command"
-  | "option"
-  | "argument"
-  | "placeholder"
-  | "punctuation",
-  ColorFunctionType
->;
-
-/**
- * - Infer the options type from a subcommand.
- *
- * @deprecated Use `InferOptionsOutput` instead.
- */
-export type InferOptionsType<T extends Partial<Subcommand>> = InferOptionsOutput<T>;
-
-/**
- * - Infer the options output type (after zod validation) from a subcommand.
- *
- * @example
- *   const subcommand = createSubcommand({ name: "build", options: [...] });
- *   type OptionsType = InferOptionsOutput<typeof subcommand>;
- */
-export type InferOptionsOutput<T extends Partial<Subcommand>> = T["options"] extends infer U extends Option[]
-  ? ToOptional<{ [K in U[number]["name"]]: ZodInferOutput<Extract<U[number], { name: K }>["type"]> }>
-  : undefined;
-
-/**
- * - Infer the options input type (before zod validation) from a subcommand.
- *
- * @example
- *   const subcommand = createSubcommand({ name: "build", options: [...] });
- *   type OptionsType = InferOptionsInput<typeof subcommand>;
- */
-export type InferOptionsInput<T extends Partial<Subcommand>> = T["options"] extends infer U extends Option[]
-  ? ToOptional<{ [K in U[number]["name"]]: ZodInferInput<Extract<U[number], { name: K }>["type"]> }>
-  : undefined;
-
-/**
- * - Infer the arguments output type (after zod validation) from a subcommand.
- *
- * @deprecated Use `InferArgumentsOutput` instead.
- */
-export type InferArgumentsType<T extends Partial<Subcommand>> = InferArgumentsOutput<T>;
-
-/**
- * - Infer the arguments output type (after zod validation) from a subcommand.
- *
- * @example
- *   const subcommand = createSubcommand({ name: "build", arguments: [...] });
- *   type ArgumentsType = InferArgumentsOutput<typeof subcommand>;
- */
-export type InferArgumentsOutput<T extends Partial<Subcommand>> = T["arguments"] extends infer U extends Argument[]
-  ? { [K in keyof U]: U[K] extends { type: Schema } ? ZodInferOutput<U[K]["type"]> : never }
-  : undefined;
-
-/**
- * - Infer the arguments Input type (before zod validation) from a subcommand.
- *
- * @example
- *   const subcommand = createSubcommand({ name: "build", arguments: [...] });
- *   type ArgumentsType = InferArgumentsInput<typeof subcommand>;
- */
-export type InferArgumentsInput<T extends Partial<Subcommand>> = T["arguments"] extends infer U extends Argument[]
-  ? { [K in keyof U]: U[K] extends { type: Schema } ? ZodInferInput<U[K]["type"]> : never }
-  : undefined;
-
-/** `{ some props } & { other props }` => `{ some props, other props }` */
-export type Prettify<T> = { [K in keyof T]: T[K] } & {};
-
-/** Allow string type for literal union and get auto completion */
-export type LiteralUnion<T extends string> = T | (string & {});
-
-/** 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> = Prettify<
-  Partial<Pick<T, UndefinedProperties<T>>> & Pick<T, Exclude<keyof T, UndefinedProperties<T>>>
->;
-
-export type NoSubcommand = { name: undefined };
-
-export type PrintMethods<N extends Subcommand["name"]> = {
-  printCliHelp: (style?: Partial<HelpMessageStyle>) => void;
-  printSubcommandHelp: (subcommand: LiteralUnion<NonNullable<N>>, style?: Partial<HelpMessageStyle>) => void;
-};
-
-export type UnsafeParseResult<S extends Partial<Subcommand>[]> =
-  CheckDuplicatedSubcommands<S> extends infer E extends string
-    ? E
-    : Prettify<ValidateResult<S> & PrintMethods<NonNullable<S[number]["name"]>>>;
-
-export type SafeParseResult<S extends Partial<Subcommand>[]> =
-  CheckDuplicatedSubcommands<S> extends infer E extends string
-    ? E
-    : Prettify<
-        ({ success: false; error: Error } | { success: true; data: ValidateResult<S> }) &
-          PrintMethods<NonNullable<S[number]["name"]>>
-      >;
-
-export type ActionsFunctions<T extends Subcommand | Cli> = {
-  setAction: (actions: (data: UnsafeParseResult<[T]>) => void) => void;
-  setPreValidationHook: (hook: (context: ParseResult<[T]>) => void) => void;
-};
-
-/** - Combine `name` and `aliases` to a `string[]` */
-type MapNameAndAliasesToStringArray<T extends { name?: string; aliases?: string[] }[]> = T extends [
-  infer First extends Subcommand,
-  ...infer Rest,
-]
-  ? Rest extends { name?: string; aliases?: string[] }[]
-    ? [
-        First["name"],
-        ...(First["aliases"] extends string[] ? First["aliases"] : []),
-        ...MapNameAndAliasesToStringArray<Rest>,
-      ]
-    : [First["name"], ...(First["aliases"] extends string[] ? First["aliases"] : [])]
-  : [];
-
-/**
- * - Find duplicated items in an array and return it
- * - Return `false` if not found
- */
-type IsDuplicatesInArray<Input extends any[]> = Input extends [infer Item, ...infer Rest]
-  ? Rest extends any[]
-    ? Item extends Rest[number]
-      ? Item
-      : IsDuplicatesInArray<Rest>
-    : false
-  : false;
-
-/**
- * - Check if there are duplicated options including aliases in `subcommand`
- * - Return an error message if duplicated is found
- * - Return `undefined` if not found
- */
-export type CheckDuplicatedOptions<T extends { options?: Option[] }> = T["options"] extends infer O extends Option[]
-  ? IsDuplicatesInArray<MapNameAndAliasesToStringArray<O>> extends infer Name extends string
-    ? `>>> Error: Duplicated Options. Check the options with the name \`${Name}\` <<<`
-    : undefined
-  : undefined;
-
-/**
- * - Check for duplicated subcommands including aliases
- * - Return an error message if duplicated is found
- * - Return the `undefined` if no error
- */
-type CheckDuplicatedSubcommands<T extends Partial<Subcommand>[]> =
-  IsDuplicatesInArray<MapNameAndAliasesToStringArray<T>> extends infer Name extends string
-    ? `>>> Error: Duplicated Subcommand. Check the subcommands with the name \`${Name}\` <<<`
-    : undefined;
-
-/**
- * - Check for duplicated arguments
- * - Return an error message if duplicated is found
- * - Return the `undefined` if no error
- */
-export type CheckDuplicatedArguments<T extends { arguments?: Argument[] }> = T["arguments"] extends infer A extends
-  Argument[]
-  ? IsDuplicatesInArray<MapNameAndAliasesToStringArray<A>> extends infer Name extends string
-    ? `>>> Error: Duplicated Arguments. Check the arguments with the name \`${Name}\` <<<`
-    : undefined
-  : undefined;
-
-type OptionalUnion = Z3.ZodOptional<Z3.ZodAny> | Z4.$ZodOptional | Z3.ZodDefault<Z3.ZodAny> | Z4.$ZodDefault;
-
-/**
- * - Insures that only the last argument is optional
- * - Insures no optional arguments are allowed when `allowPositional` is enabled
- */
-export type CheckArgumentsOptional<T extends { allowPositional?: boolean; arguments?: readonly Argument[] }> =
-  T["arguments"] extends readonly [...infer Rest, infer Last]
-    ? Last extends { type: OptionalUnion }
-      ? T["allowPositional"] extends true
-        ? `>>> Error: Cannot have optional arguments when \`allowPositional\` is enabled. The argument \`${Last extends { name: string } ? Last["name"] : ""}\` should not be optional <<<`
-        : T
-      : Extract<Rest[number], { type: OptionalUnion }> extends never
-        ? T
-        : T["allowPositional"] extends true
-          ? `>>> Error: Cannot have optional arguments when \`allowPositional\` is enabled. The argument \`${Rest[number] extends { name: string } ? Rest[number]["name"] : ""}\` should not be optional <<<`
-          : `>>> Error: Only the last argument may be optional. The argument \`${Rest[number] extends { name: string } ? Rest[number]["name"] : ""}\` should not be optional <<<`
-    : T;

package/src/zod-utilities.ts

@@ -1,214 +0,0 @@
-import { ZodBoolean, ZodDefault, ZodEffects } from "zod/v3";
-import { safeParse } from "zod/v4/core";
-
-import type * as Z3 from "zod/v3";
-import type * as Z4 from "zod/v4/core";
-import type { Schema, SchemaV3, SchemaV4 } from "./types.ts";
-
-function isV4Schema(schema: Schema): schema is SchemaV4 {
-  return "_zod" in schema;
-}
-
-/** - Safe parse a value against a schema */
-export function safeParseSchema(schema: Schema, value: unknown) {
-  if (isV4Schema(schema)) {
-    return safeParse(schema, value);
-  }
-
-  return schema.safeParse(value);
-}
-
-/** - Check if a schema is a boolean */
-export function isBooleanSchema(schema: Schema): boolean {
-  if (isV4Schema(schema)) {
-    return isBooleanV4Schema(schema);
-  }
-
-  return isBooleanV3Schema(schema);
-}
-
-function isBooleanV4Schema(schema: SchemaV4): boolean {
-  let schemaDefinition = schema._zod.def;
-
-  while (schemaDefinition) {
-    if (schemaDefinition.type === "boolean") {
-      return true;
-    }
-
-    if (isV4SchemaDefinitionPipe(schemaDefinition)) {
-      return isBooleanV4Schema(schemaDefinition.out);
-    }
-
-    if (!isV4SchemaDefinitionHasInnerType(schemaDefinition)) {
-      return false;
-    }
-
-    schemaDefinition = schemaDefinition.innerType._zod.def;
-  }
-
-  return false;
-}
-
-function isBooleanV3Schema(schema: SchemaV3): boolean {
-  let type = schema;
-
-  while (type) {
-    if (type instanceof ZodBoolean) {
-      return true;
-    }
-
-    if (type instanceof ZodEffects) {
-      return isBooleanV3Schema(type._def.schema as SchemaV3);
-    }
-
-    const definition = type._def as Z3.ZodTypeDef;
-
-    if ("innerType" in definition) {
-      type = definition.innerType as Z3.ZodTypeAny;
-    }
-
-    return false;
-  }
-
-  return false;
-}
-
-/** - Get the default value of a schema */
-export function schemaDefaultValue(schema: Schema): unknown {
-  if (isV4Schema(schema)) {
-    return schemaV4DefaultValue(schema);
-  }
-
-  return schemaV3DefaultValue(schema);
-}
-
-function schemaV4DefaultValue(schema: SchemaV4): unknown {
-  let schemaDefinition = schema._zod.def;
-
-  while (schemaDefinition) {
-    if (isSchemaDefinitionDefaultV4(schemaDefinition)) {
-      return schemaDefinition.defaultValue;
-    }
-
-    if (isV4SchemaDefinitionPipe(schemaDefinition)) {
-      return schemaV4DefaultValue(schemaDefinition.out);
-    }
-
-    if (!isV4SchemaDefinitionHasInnerType(schemaDefinition)) {
-      return undefined;
-    }
-
-    schemaDefinition = schemaDefinition.innerType._zod.def;
-  }
-
-  return undefined;
-}
-
-function schemaV3DefaultValue(schema: SchemaV3): unknown {
-  let type = schema;
-  while (type) {
-    if (type instanceof ZodDefault) {
-      return type._def.defaultValue();
-    }
-
-    if (type instanceof ZodEffects) {
-      return schemaV3DefaultValue(type._def.schema as SchemaV3);
-    }
-
-    const definition = type._def as Z3.ZodTypeDef;
-
-    if ("innerType" in definition) {
-      type = definition.innerType as Z3.ZodTypeAny;
-    }
-
-    return;
-  }
-
-  return;
-}
-
-/** - Get the description of a schema */
-export function schemaDescription(schema: Schema): string | undefined {
-  if (isV4Schema(schema)) {
-    if (!("meta" in schema) || typeof schema.meta !== "function") {
-      return;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-    const metaResult = schema.meta() as { description?: string } | undefined;
-
-    if (!metaResult || typeof metaResult !== "object" || !("description" in metaResult)) {
-      return;
-    }
-
-    return metaResult.description;
-  }
-
-  return schema.description;
-}
-
-/** - Check if a schema is optional */
-export function isOptionalSchema(schema: Schema): schema is Z4.$ZodOptional {
-  if (isV4Schema(schema)) {
-    return schema._zod.def.type === "optional" || schema._zod.def.type === "default";
-  }
-
-  return schema.isOptional();
-}
-
-function isSchemaDefinitionDefaultV4(schemaDefinition: Z4.$ZodTypeDef): schemaDefinition is Z4.$ZodDefaultDef {
-  return schemaDefinition.type === "default";
-}
-
-type SchemaWithInnerType =
-  | Z4.$ZodDefaultDef
-  | Z4.$ZodPrefaultDef
-  | Z4.$ZodOptionalDef
-  | Z4.$ZodNonOptionalDef
-  | Z4.$ZodNullableDef
-  | Z4.$ZodSuccessDef
-  | Z4.$ZodCatchDef
-  | Z4.$ZodReadonlyDef
-  | Z4.$ZodPromiseDef;
-
-function isV4SchemaDefinitionHasInnerType(schemaDefinition: Z4.$ZodTypeDef): schemaDefinition is SchemaWithInnerType {
-  return new Set([
-    "default",
-    "prefault",
-    "optional",
-    "nonoptional",
-    "nullable",
-    "success",
-    "catch",
-    "readonly",
-    "promise",
-  ]).has(schemaDefinition.type);
-}
-
-function isV4SchemaDefinitionPipe(schemaDefinition: Z4.$ZodTypeDef): schemaDefinition is Z4.$ZodPipeDef {
-  return schemaDefinition.type === "pipe";
-}
-
-/**
- * A preprocessing function for Zod that converts a string to an array of strings.
- *
- * @param stringValue - The string value given by zod.
- * @param separator - The separator to use when splitting the string. Defaults to ",".
- */
-export function stringToArray(stringValue: string, separator: string = ","): string[] {
-  return stringValue
-    .split(separator)
-    .map(s => s.trim())
-    .filter(Boolean);
-}
-
-/**
- * A preprocessing function for Zod that converts a string to a `Set` of strings.
- *
- * @param stringValue - The string value given by zod.
- * @param separator - The separator to use when splitting the string. Defaults to ",".
- */
-export function stringToSet(stringValue: string, separator: string = ","): Set<string> {
-  const maybeArray = stringToArray(stringValue, separator);
-  return new Set(maybeArray);
-}