zod-args-parser 1.2.7 → 1.2.8

package/src/parser/parse/parser-helpers.ts

@@ -8,8 +8,8 @@ import type { Option, Subcommand } from "../../types.js";
  * @param subcommandArr - An array of `Subcommand` objects to search within.
  * @returns The matching `Subcommand` object if found; otherwise, `undefined`.
  */
-export function findSubcommand(subCmdName: string | undefined, subcommandArr: Subcommand[]): Subcommand | undefined {
-  return subcommandArr.find(c => {
+export function findSubcommand(subCmdName: string | undefined, subcommandArray: Subcommand[]): Subcommand | undefined {
+  return subcommandArray.find(c => {
     // match for undefined too
     if (c.name === subCmdName) {
       return true;
@@ -29,16 +29,16 @@ export function findSubcommand(subCmdName: string | undefined, subcommandArr: Su
  * @param options - An array of `Option` objects to search through.
  * @returns The matching `Option` object if found; otherwise, `undefined`.
  */
-export function findOption(optionArg: string, options: [Option, ...Option[]]): Option | undefined {
-  const validVarNames = optionArgToVarNames(optionArg);
-  const isNegative = optionArg.startsWith("--no-");
+export function findOption(optionArgument: string, options: [Option, ...Option[]]): Option | undefined {
+  const validVariableNames = optionArgumentToVariableNames(optionArgument);
+  const isNegative = optionArgument.startsWith("--no-");
 
   const option = options.find(o => {
-    if (validVarNames.has(o.name)) {
+    if (validVariableNames.has(o.name)) {
       return true;
     }
 
-    if (isNegative && validVarNames.has(negateOption(o.name))) {
+    if (isNegative && validVariableNames.has(negateOption(o.name))) {
       return true;
     }
 
@@ -46,11 +46,11 @@ export function findOption(optionArg: string, options: [Option, ...Option[]]): O
       return false;
     }
 
-    if (o.aliases.some(a => validVarNames.has(a))) {
+    if (o.aliases.some(a => validVariableNames.has(a))) {
       return true;
     }
 
-    if (isNegative && o.aliases.map(negateOption).some(a => validVarNames.has(a))) {
+    if (isNegative && o.aliases.map(alias => negateOption(alias)).some(a => validVariableNames.has(a))) {
       return true;
     }
 
@@ -61,25 +61,24 @@ export function findOption(optionArg: string, options: [Option, ...Option[]]): O
 }
 
 /** - Decouple flags E.g. `-rf` -> `-r, -f` */
-export function decoupleFlags(args: string[]): string[] {
+export function decoupleFlags(arguments_: string[]): string[] {
   const flagsRe = /^-[a-z0-9]{2,}$/i;
 
   const result = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const isCoupled = flagsRe.test(arg);
+  for (const argument of arguments_) {
+    const isCoupled = flagsRe.test(argument);
 
     if (!isCoupled) {
-      result.push(arg);
+      result.push(argument);
       continue;
     }
 
-    const decoupledArr = arg
-      .substring(1)
+    const decoupledArray = argument
+      .slice(1)
       .split("")
       .map(c => "-" + c);
 
-    result.push(...decoupledArr);
+    result.push(...decoupledArray);
   }
 
   return result;
@@ -90,12 +89,12 @@ export function decoupleFlags(args: string[]): string[] {
  *
  * @param name - Should start with `'--'` or `'-'`
  */
-export function optionArgToVarNames(name: string): Set<string> {
+export function optionArgumentToVariableNames(name: string): Set<string> {
   if (!name.startsWith("-")) {
     throw new Error(`[parseArgOptionName] Invalid arg name: ${name}`, { cause: "zod-args-parser" });
   }
 
-  name = name.startsWith("--") ? name.substring(2) : name.substring(1); // remove prefix
+  name = name.startsWith("--") ? name.slice(2) : name.slice(1); // remove prefix
   name = name.toLowerCase(); // lowercase
 
   const results = new Set<string>();
@@ -118,22 +117,22 @@ export function optionArgToVarNames(name: string): Set<string> {
 }
 
 /** - Check if an arg string is a short arg. E.g. `-i` -> `true` */
-export function isFlagArg(name: string): boolean {
+export function isFlagArgument(name: string): boolean {
   return /^-[A-Za-z]$/.test(name);
 }
 
 /** - Check if an arg string is a long arg. E.g. `--input-dir` -> `true` */
-function isLongArg(name: string): boolean {
+function isLongArgument(name: string): boolean {
   return /^--[A-Za-z-]+[A-Za-z0-9]$/.test(name);
 }
 
 /** - Check if an arg string is an options arg. E.g. `--input-dir` -> `true` , `-i` -> `true` */
-export function isOptionArg(name: string | boolean): boolean {
+export function isOptionArgument(name: string | boolean): boolean {
   if (typeof name !== "string") {
     return false;
   }
 
-  return isFlagArg(name) || isLongArg(name);
+  return isFlagArgument(name) || isLongArgument(name);
 }
 
 /**
@@ -149,7 +148,7 @@ export function negateOption(name: string): string {
 }
 
 /** - Reverse of `transformArg`. E.g. `InputDir` -> `--input-dir` , `i` -> `-i` */
-export function transformOptionToArg(name: string): string {
+export function transformOptionToArgument(name: string): string {
   // single letter option name
   if (name.length === 1) {
     return `-${name.toLowerCase()}`;
@@ -162,6 +161,6 @@ export function transformOptionToArg(name: string): string {
   }
 
   // camelCase, PascalCase
-  name = name.replace(/[A-Z]/g, (m, i) => (i ? "-" + m : m)); // add "-" before camel case letters except for the first letter
+  name = name.replace(/[A-Z]/g, (match, index: number) => (index > 0 ? "-" + match : match)); // add "-" before camel case letters except for the first letter
   return `--${name.toLowerCase()}`;
 }

package/src/parser/safe-parse.ts

@@ -6,19 +6,19 @@ import type { Cli, NoSubcommand, PrintMethods, SafeParseResult, Subcommand } fro
 
 export function safeParse<T extends Subcommand[], U extends Cli>(
   argsv: string[],
-  ...params: [U, ...T]
+  ...parameters: [U, ...T]
 ): SafeParseResult<[...T, NoSubcommand & U]> {
-  const cliOptions = ("cliName" in params[0] ? params[0] : {}) as U;
-  const subcommandArr = params as Subcommand[];
+  const cliOptions = ("cliName" in parameters[0] ? parameters[0] : {}) as U;
+  const subcommandArray = parameters as Subcommand[];
 
   type PrintTypes = PrintMethods<T[number]["name"]>;
   type PrintCli = PrintTypes["printCliHelp"];
   type PrintSubcommand = PrintTypes["printSubcommandHelp"];
 
-  const printCliHelp: PrintCli = style => help.printCliHelp(params, style);
+  const printCliHelp: PrintCli = style => help.printCliHelp(parameters, style);
 
   const printSubcommandHelp: PrintSubcommand = (subCmdName, style) => {
-    const subcommand = findSubcommand(subCmdName, subcommandArr);
+    const subcommand = findSubcommand(subCmdName, subcommandArray);
     if (!subcommand) {
       return console.error(`Cannot print help for subcommand "${subCmdName}" as it does not exist`);
     }
@@ -27,7 +27,7 @@ export function safeParse<T extends Subcommand[], U extends Cli>(
   };
 
   try {
-    const data = unsafeParse(argsv, ...params);
+    const data = unsafeParse(argsv, ...parameters);
     // @ts-expect-error The operand of a 'delete' operator must be optional.
     delete data.printCliHelp;
     // @ts-expect-errorThe operand of a 'delete' operator must be optional.
@@ -39,11 +39,14 @@ export function safeParse<T extends Subcommand[], U extends Cli>(
       printCliHelp,
       printSubcommandHelp,
     } as SafeParseResult<[...T, NoSubcommand & U]>;
-  } catch (e) {
-    if (!(e instanceof Error) || e.cause !== "zod-args-parser") throw e;
+  } catch (error) {
+    if (!(error instanceof Error) || error.cause !== "zod-args-parser") {
+      throw error;
+    }
+
     return {
       success: false,
-      error: e as Error,
+      error,
       printCliHelp,
       printSubcommandHelp,
     } as SafeParseResult<[...T, NoSubcommand & U]>;
@@ -52,19 +55,19 @@ export function safeParse<T extends Subcommand[], U extends Cli>(
 
 export async function safeParseAsync<T extends Subcommand[], U extends Cli>(
   argsv: string[],
-  ...params: [U, ...T]
+  ...parameters: [U, ...T]
 ): Promise<SafeParseResult<[...T, NoSubcommand & U]>> {
-  const cliOptions = ("cliName" in params[0] ? params[0] : {}) as U;
-  const subcommandArr = params as Subcommand[];
+  const cliOptions = ("cliName" in parameters[0] ? parameters[0] : {}) as U;
+  const subcommandArray = parameters as Subcommand[];
 
   type PrintTypes = PrintMethods<T[number]["name"]>;
   type PrintCli = PrintTypes["printCliHelp"];
   type PrintSubcommand = PrintTypes["printSubcommandHelp"];
 
-  const printCliHelp: PrintCli = style => help.printCliHelp(params, style);
+  const printCliHelp: PrintCli = style => help.printCliHelp(parameters, style);
 
   const printSubcommandHelp: PrintSubcommand = (subCmdName, style) => {
-    const subcommand = findSubcommand(subCmdName, subcommandArr);
+    const subcommand = findSubcommand(subCmdName, subcommandArray);
     if (!subcommand) {
       return console.error(`Cannot print help for subcommand "${subCmdName}" as it does not exist`);
     }
@@ -73,7 +76,7 @@ export async function safeParseAsync<T extends Subcommand[], U extends Cli>(
   };
 
   try {
-    const data = await unsafeParseAsync(argsv, ...params);
+    const data = await unsafeParseAsync(argsv, ...parameters);
     // @ts-expect-error The operand of a 'delete' operator must be optional.
     delete data.printCliHelp;
     // @ts-expect-errorThe operand of a 'delete' operator must be optional.
@@ -85,11 +88,14 @@ export async function safeParseAsync<T extends Subcommand[], U extends Cli>(
       printCliHelp,
       printSubcommandHelp,
     } as SafeParseResult<[...T, NoSubcommand & U]>;
-  } catch (e) {
-    if (!(e instanceof Error) || e.cause !== "zod-args-parser") throw e;
+  } catch (error) {
+    if (!(error instanceof Error) || error.cause !== "zod-args-parser") {
+      throw error;
+    }
+
     return {
       success: false,
-      error: e as Error,
+      error,
       printCliHelp,
       printSubcommandHelp,
     } as SafeParseResult<[...T, NoSubcommand & U]>;

package/src/parser/unsafe-parse.ts

@@ -1,51 +1,51 @@
 import * as help from "../help-message/format-cli.js";
+import { parse } from "./parse/parse.js";
 import { findSubcommand } from "./parse/parser-helpers.js";
 import { validate } from "./validate/validate.js";
-import { parse } from "./parse/parse.js";
 
-import type { Cli, NoSubcommand, HelpMsgStyle, Subcommand, UnsafeParseResult } from "../types.js";
+import type { Cli, HelpMessageStyle, NoSubcommand, Subcommand, UnsafeParseResult } from "../types.js";
 
 export function unsafeParse<T extends Subcommand[], U extends Cli>(
   argv: string[],
-  ...params: [U, ...T]
+  ...parameters: [U, ...T]
 ): UnsafeParseResult<[...T, NoSubcommand & U]> {
-  const cliOptions = ("cliName" in params[0] ? params[0] : {}) as U;
-  const subcommandArr = params as unknown as T;
+  const cliOptions = ("cliName" in parameters[0] ? parameters[0] : {}) as U;
+  const subcommandArray = parameters as unknown as T;
 
   // Parse
-  const parsedData = parse(argv, ...params);
+  const parsedData = parse(argv, ...parameters);
 
-  const subcommandObj = findSubcommand(parsedData.subcommand, subcommandArr);
-  if (!subcommandObj) {
+  const subcommandObject = findSubcommand(parsedData.subcommand, subcommandArray);
+  if (!subcommandObject) {
     throw new Error(`Subcommand "${parsedData.subcommand}" does not exist`, { cause: "zod-args-parser" });
   }
 
   // Fire preValidation hook
-  if (subcommandObj.preValidation) {
-    subcommandObj.preValidation(parsedData);
+  if (subcommandObject.preValidation) {
+    subcommandObject.preValidation(parsedData);
   }
 
   // Validate
   const validateResult = validate(parsedData);
 
   Object.assign(validateResult, {
-    printCliHelp(style?: Partial<HelpMsgStyle>) {
-      help.printCliHelp(params, style);
+    printCliHelp(style?: Partial<HelpMessageStyle>) {
+      help.printCliHelp(parameters, style);
     },
-    printSubcommandHelp(subCmdName: string, style?: Partial<HelpMsgStyle>) {
-      const subcommandObj = findSubcommand(subCmdName, subcommandArr);
-      if (!subcommandObj) {
+    printSubcommandHelp(subCmdName: string, style?: Partial<HelpMessageStyle>) {
+      const subcommandObject = findSubcommand(subCmdName, subcommandArray);
+      if (!subcommandObject) {
         console.error(`Cannot print help for subcommand "${subCmdName}" as it does not exist`);
         return;
       }
 
-      help.printSubcommandHelp(subcommandObj, style, cliOptions.cliName);
+      help.printSubcommandHelp(subcommandObject, style, cliOptions.cliName);
     },
   });
 
   // Fire action
-  if (subcommandObj.action) {
-    subcommandObj.action(validateResult);
+  if (subcommandObject.action) {
+    subcommandObject.action(validateResult);
   }
 
   return validateResult as UnsafeParseResult<[...T, NoSubcommand & U]>;
@@ -53,45 +53,45 @@ export function unsafeParse<T extends Subcommand[], U extends Cli>(
 
 export async function unsafeParseAsync<T extends Subcommand[], U extends Cli>(
   argv: string[],
-  ...params: [U, ...T]
+  ...parameters: [U, ...T]
 ): Promise<UnsafeParseResult<[...T, NoSubcommand & U]>> {
-  const cliOptions = ("cliName" in params[0] ? params[0] : {}) as U;
-  const subcommandArr = params as unknown as T;
+  const cliOptions = ("cliName" in parameters[0] ? parameters[0] : {}) as U;
+  const subcommandArray = parameters as unknown as T;
 
   // Parse
-  const parsedData = parse(argv, ...params);
+  const parsedData = parse(argv, ...parameters);
 
-  const subcommandObj = findSubcommand(parsedData.subcommand, subcommandArr);
-  if (!subcommandObj) {
+  const subcommandObject = findSubcommand(parsedData.subcommand, subcommandArray);
+  if (!subcommandObject) {
     throw new Error(`Subcommand "${parsedData.subcommand}" does not exist`, { cause: "zod-args-parser" });
   }
 
   // Fire preValidation hook
-  if (subcommandObj.preValidation) {
-    await subcommandObj.preValidation(parsedData);
+  if (subcommandObject.preValidation) {
+    await subcommandObject.preValidation(parsedData);
   }
 
   // Validate
   const validateResult = validate(parsedData);
 
   Object.assign(validateResult, {
-    printCliHelp(style?: Partial<HelpMsgStyle>) {
-      help.printCliHelp(params, style);
+    printCliHelp(style?: Partial<HelpMessageStyle>) {
+      help.printCliHelp(parameters, style);
     },
-    printSubcommandHelp(subCmdName: string, style?: Partial<HelpMsgStyle>) {
-      const subcommandObj = findSubcommand(subCmdName, subcommandArr);
-      if (!subcommandObj) {
+    printSubcommandHelp(subCmdName: string, style?: Partial<HelpMessageStyle>) {
+      const subcommandObject = findSubcommand(subCmdName, subcommandArray);
+      if (!subcommandObject) {
         console.error(`Cannot print help for subcommand "${subCmdName}" as it does not exist`);
         return;
       }
 
-      help.printSubcommandHelp(subcommandObj, style, cliOptions.cliName);
+      help.printSubcommandHelp(subcommandObject, style, cliOptions.cliName);
     },
   });
 
   // Fire action
-  if (subcommandObj.action) {
-    await subcommandObj.action(validateResult);
+  if (subcommandObject.action) {
+    await subcommandObject.action(validateResult);
   }
 
   return validateResult as UnsafeParseResult<[...T, NoSubcommand & U]>;

package/src/parser/validate/validate-type.ts

@@ -1,11 +1,11 @@
 import type { Argument, Option, Prettify, Schema, Subcommand, ToOptional, ZodInferOutput } from "../../types.js";
 import type { ParseResult } from "../parse/parse-types.js";
 
-type OptionsArr2RecordType<T extends Option[] | undefined> = T extends Option[]
+type OptionsArray2RecordType<T extends Option[] | undefined> = T extends Option[]
   ? ToOptional<{ [K in T[number]["name"]]: ZodInferOutput<Extract<T[number], { name: K }>["type"]> }>
   : object;
 
-type ArgumentsArr2ArrType<T extends Argument[] | undefined> = T extends Argument[]
+type ArgumentsArray2ArrayType<T extends Argument[] | undefined> = T extends Argument[]
   ? { [K in keyof T]: T[K] extends { type: Schema } ? ZodInferOutput<T[K]["type"]> : never }
   : never;
 
@@ -13,9 +13,9 @@ export type ValidateResult<S extends Partial<Subcommand>[]> = {
   [K in keyof S]: Prettify<
     {
       subcommand: S[K]["name"] extends string ? S[K]["name"] : undefined;
-      arguments: ArgumentsArr2ArrType<S[K]["arguments"]>;
+      arguments: ArgumentsArray2ArrayType<S[K]["arguments"]>;
       positional: S[K]["allowPositional"] extends true ? string[] : never;
       ctx: ParseResult<S>;
-    } & OptionsArr2RecordType<S[K]["options"]>
+    } & OptionsArray2RecordType<S[K]["options"]>
   >;
 }[number];

package/src/parser/validate/validate.ts

@@ -1,20 +1,20 @@
-import { prettifyError } from "zod/v4";
+import { prettifyError } from "zod/v4/core";
 
-import { generateOrdinalSuffix, stringToBoolean } from "../../utils.js";
-import { isBooleanSchema, safeParseSchema } from "../../zod-utils.js";
+import { generateOrdinalSuffix, stringToBoolean } from "../../utilities.js";
+import { isBooleanSchema, safeParseSchema } from "../../zod-utilities.js";
 
-import type { ParseCtx } from "../parse/parse-types.js";
+import type { ParsedContext } from "../parse/parse-types.js";
 
 /** The return result object temporarily type. used inside the `parse` function */
-type ResultsTempType = Record<string, unknown> & {
+type ResultsTemporaryType = Record<string, unknown> & {
   subcommand: string | undefined;
   positional?: string[];
   arguments?: unknown[];
-  ctx: ParseCtx;
+  ctx: ParsedContext;
 };
 
-export function validate(parsedData: ParseCtx) {
-  const results: ResultsTempType = {
+export function validate(parsedData: ParsedContext) {
+  const results: ResultsTemporaryType = {
     subcommand: parsedData.subcommand,
     positional: parsedData.positional,
     ctx: parsedData,
@@ -33,14 +33,14 @@ export function validate(parsedData: ParseCtx) {
       }
     }
 
-    const res = safeParseSchema(schema, optionsValue);
-    if (!res.success) {
-      throw new Error(`Invalid value "${rawValue}" for "${flag}": ${prettifyError(res.error)}`, {
+    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] = res.data;
+    results[optionName] = safeParseResult.data;
   }
 
   // validate arguments
@@ -48,17 +48,17 @@ export function validate(parsedData: ParseCtx) {
     if (!results.arguments) results.arguments = [];
 
     for (const { schema, rawValue } of parsedData.arguments) {
-      const argValue = rawValue && isBooleanSchema(schema) ? stringToBoolean(rawValue) : rawValue;
+      const argumentValue = rawValue && isBooleanSchema(schema) ? stringToBoolean(rawValue) : rawValue;
 
-      const res = safeParseSchema(schema, argValue);
-      if (!res.success) {
+      const safeParseResult = safeParseSchema(schema, argumentValue);
+      if (!safeParseResult.success) {
         throw new Error(
-          `The ${generateOrdinalSuffix(results.arguments.length)} argument "${rawValue}" is invalid: ${prettifyError(res.error)}`,
+          `The ${generateOrdinalSuffix(results.arguments.length)} argument "${rawValue}" is invalid: ${prettifyError(safeParseResult.error)}`,
           { cause: "zod-args-parser" },
         );
       }
 
-      results.arguments.push(res.data);
+      results.arguments.push(safeParseResult.data);
     }
   }
 

package/src/types.ts

@@ -85,7 +85,7 @@ export interface Subcommand {
    *   const helpCommand = createSubcommand({ name: "help", options: [...] });
    *   helpCommand.setAction(res => console.log(res));
    */
-  action?: (results?: any) => any;
+  action?: (data?: any) => any;
 
   /**
    * - The preValidation hook is executed before the action.
@@ -95,7 +95,7 @@ export interface Subcommand {
    *   const helpCommand = createSubcommand({ name: "help", options: [...] });
    *   helpCommand.setPreValidationHook(ctx => console.log(ctx));
    */
-  preValidation?: (ctx?: any) => any;
+  preValidation?: (context?: any) => any;
 }
 
 export type Cli = Prettify<
@@ -171,10 +171,10 @@ export interface Argument {
   example?: string;
 }
 
-export type ColorFnType = (...text: unknown[]) => string;
+export type ColorFunctionType = (...text: unknown[]) => string;
 
 /** - The colors to use for the help message. */
-export type HelpMsgStyle = Record<
+export type HelpMessageStyle = Record<
   | "title"
   | "description"
   | "default"
@@ -186,7 +186,7 @@ export type HelpMsgStyle = Record<
   | "argument"
   | "placeholder"
   | "punctuation",
-  ColorFnType
+  ColorFunctionType
 >;
 
 /**
@@ -264,8 +264,8 @@ export type ToOptional<T> = Prettify<
 export type NoSubcommand = { name: undefined };
 
 export type PrintMethods<N extends Subcommand["name"]> = {
-  printCliHelp: (style?: Partial<HelpMsgStyle>) => void;
-  printSubcommandHelp: (subcommand: LiteralUnion<NonNullable<N>>, style?: Partial<HelpMsgStyle>) => void;
+  printCliHelp: (style?: Partial<HelpMessageStyle>) => void;
+  printSubcommandHelp: (subcommand: LiteralUnion<NonNullable<N>>, style?: Partial<HelpMessageStyle>) => void;
 };
 
 export type UnsafeParseResult<S extends Partial<Subcommand>[]> =
@@ -281,18 +281,22 @@ export type SafeParseResult<S extends Partial<Subcommand>[]> =
           PrintMethods<NonNullable<S[number]["name"]>>
       >;
 
-export type ActionsFn<T extends Subcommand | Cli> = {
-  setAction: (actions: (res: UnsafeParseResult<[T]>) => void) => void;
-  setPreValidationHook: (hookFn: (ctx: ParseResult<[T]>) => void) => void;
+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 MapNameAndAliases2StrArr<T extends { name?: string; aliases?: string[] }[]> = T extends [
+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"] : []), ...MapNameAndAliases2StrArr<Rest>]
+    ? [
+        First["name"],
+        ...(First["aliases"] extends string[] ? First["aliases"] : []),
+        ...MapNameAndAliasesToStringArray<Rest>,
+      ]
     : [First["name"], ...(First["aliases"] extends string[] ? First["aliases"] : [])]
   : [];
 
@@ -300,11 +304,11 @@ type MapNameAndAliases2StrArr<T extends { name?: string; aliases?: string[] }[]>
  * - Find duplicated items in an array and return it
  * - Return `false` if not found
  */
-type IsDuplicatesInArr<Input extends any[]> = Input extends [infer Item, ...infer Rest]
+type IsDuplicatesInArray<Input extends any[]> = Input extends [infer Item, ...infer Rest]
   ? Rest extends any[]
     ? Item extends Rest[number]
       ? Item
-      : IsDuplicatesInArr<Rest>
+      : IsDuplicatesInArray<Rest>
     : false
   : false;
 
@@ -314,7 +318,7 @@ type IsDuplicatesInArr<Input extends any[]> = Input extends [infer Item, ...infe
  * - Return `undefined` if not found
  */
 export type CheckDuplicatedOptions<T extends { options?: Option[] }> = T["options"] extends infer O extends Option[]
-  ? IsDuplicatesInArr<MapNameAndAliases2StrArr<O>> extends infer Name extends string
+  ? IsDuplicatesInArray<MapNameAndAliasesToStringArray<O>> extends infer Name extends string
     ? `>>> Error: Duplicated Options. Check the options with the name \`${Name}\` <<<`
     : undefined
   : undefined;
@@ -325,7 +329,7 @@ export type CheckDuplicatedOptions<T extends { options?: Option[] }> = T["option
  * - Return the `undefined` if no error
  */
 type CheckDuplicatedSubcommands<T extends Partial<Subcommand>[]> =
-  IsDuplicatesInArr<MapNameAndAliases2StrArr<T>> extends infer Name extends string
+  IsDuplicatesInArray<MapNameAndAliasesToStringArray<T>> extends infer Name extends string
     ? `>>> Error: Duplicated Subcommand. Check the subcommands with the name \`${Name}\` <<<`
     : undefined;
 
@@ -336,7 +340,7 @@ type CheckDuplicatedSubcommands<T extends Partial<Subcommand>[]> =
  */
 export type CheckDuplicatedArguments<T extends { arguments?: Argument[] }> = T["arguments"] extends infer A extends
   Argument[]
-  ? IsDuplicatesInArr<MapNameAndAliases2StrArr<A>> extends infer Name extends string
+  ? IsDuplicatesInArray<MapNameAndAliasesToStringArray<A>> extends infer Name extends string
     ? `>>> Error: Duplicated Arguments. Check the arguments with the name \`${Name}\` <<<`
     : undefined
   : undefined;