zod-args-parser 1.2.7 → 1.2.8

package/src/help-message/format-cli.ts

@@ -1,21 +1,24 @@
 import { getCliMetadata } from "../metadata/get-cli-metadata.js";
-import { concat, indent, ln, subcommandPlaceholder } from "../utils.js";
-import { formatHelpMsgArguments } from "./format-arguments.js";
-import { formatHelpMsgOptions } from "./format-options.js";
-import { formatHelpMsgCommands } from "./format-subcommands.js";
-import { helpMsgStyles } from "./styles.js";
-
-import type { Cli, HelpMsgStyle, Subcommand } from "../types.js";
-
-export function formatCliHelpMsg(params: readonly [Cli, ...Subcommand[]], style?: Partial<HelpMsgStyle>): string {
-  const c = helpMsgStyles.default;
+import { concat, indent, ln, subcommandPlaceholder } from "../utilities.js";
+import { formatHelpMessageArguments } from "./format-arguments.js";
+import { formatHelpMessageOptions } from "./format-options.js";
+import { formatHelpMessageCommands } from "./format-subcommands.js";
+import { helpMessageStyles } from "./styles.js";
+
+import type { Cli, HelpMessageStyle, Subcommand } from "../types.js";
+
+export function formatCliHelpMessage(
+  parameters: readonly [Cli, ...Subcommand[]],
+  style?: Partial<HelpMessageStyle>,
+): string {
+  const c = helpMessageStyles.default;
   if (style) Object.assign(c, style);
 
-  const metadata = getCliMetadata(params);
+  const metadata = getCliMetadata(parameters);
 
   const formatTitle = (title: string) => c.title(` ${title.toUpperCase()}`);
 
-  let msg = "";
+  let message = "";
 
   // CLI usage
   const usage =
@@ -23,18 +26,18 @@ export function formatCliHelpMsg(params: readonly [Cli, ...Subcommand[]], style?
     concat(
       c.punctuation("$"),
       c.description(metadata.name),
-      metadata.subcommands.length ? c.command("[command]") : "",
-      metadata.options.length ? c.option("[options]") : "",
-      metadata.arguments.length ? c.argument("<arguments>") : "",
+      metadata.subcommands.length > 0 ? c.command("[command]") : "",
+      metadata.options.length > 0 ? c.option("[options]") : "",
+      metadata.arguments.length > 0 ? c.argument("<arguments>") : "",
       metadata.allowPositional ? c.argument("<positionals>") : "",
     );
-  msg += formatTitle("Usage") + ln(1);
-  msg += indent(2) + usage + ln(2);
+  message += formatTitle("Usage") + ln(1);
+  message += indent(2) + usage + ln(2);
 
   // CLI description
   if (metadata.description) {
-    msg += formatTitle("Description") + ln(1);
-    msg += indent(2) + c.description(metadata.description).replace(/\n+/g, "\n" + indent(2)) + ln(2);
+    message += formatTitle("Description") + ln(1);
+    message += indent(2) + c.description(metadata.description).replace(/\n+/g, "\n" + indent(2)) + ln(2);
   }
 
   let longest = 0;
@@ -42,11 +45,14 @@ export function formatCliHelpMsg(params: readonly [Cli, ...Subcommand[]], style?
   // Prepare CLI options
   const optionsMetadata = metadata.options;
 
-  const longestOptionTitle = optionsMetadata.reduce((acc, metadata) => {
-    const names = metadata.aliasesAsArgs.concat([metadata.nameAsArg]).join(", ");
+  let longestOptionTitle = 0;
+  for (const metadata of optionsMetadata) {
+    const names = [...metadata.aliasesAsArgs, metadata.nameAsArg].join(", ");
     const optLength = names.length + metadata.placeholder.length;
-    return optLength > acc ? optLength : acc;
-  }, 0);
+    if (optLength > longestOptionTitle) {
+      longestOptionTitle = optLength;
+    }
+  }
 
   if (longestOptionTitle > longest) {
     longest = longestOptionTitle;
@@ -55,46 +61,60 @@ export function formatCliHelpMsg(params: readonly [Cli, ...Subcommand[]], style?
   // Prepare CLI commands
   const subcommandsMetadata = metadata.subcommands;
 
-  const longestSubcommandTitle = subcommandsMetadata.reduce((acc, metadata) => {
-    const names = metadata.aliases.concat([metadata.name]).join(", ");
+  let longestSubcommandTitle = 0;
+  for (const metadata of subcommandsMetadata) {
+    const names = [...metadata.aliases, metadata.name].join(", ");
     const placeholder = subcommandPlaceholder(metadata);
     const optLength = names.length + placeholder.length;
-    return optLength > acc ? optLength : acc;
-  }, 0);
+    if (optLength > longestSubcommandTitle) {
+      longestSubcommandTitle = optLength;
+    }
+  }
 
   if (longestSubcommandTitle > longest) {
     longest = longestSubcommandTitle;
   }
 
   // Prepare CLI arguments
-  const argsMetadata = metadata.arguments;
-  const longestArgTitle = argsMetadata.reduce((acc, arg) => (arg.name.length > acc ? arg.name.length : acc), 0);
-  if (longestArgTitle > longest) {
-    longest = longestArgTitle;
+  const argumentsMetadata = metadata.arguments;
+
+  let longestArgumentTitle = 0;
+  for (const argument of argumentsMetadata) {
+    if (argument.name.length > longestArgumentTitle) {
+      longestArgumentTitle = argument.name.length;
+    }
+  }
+
+  if (longestArgumentTitle > longest) {
+    longest = longestArgumentTitle;
   }
 
   // CLI options
-  msg += formatHelpMsgOptions(optionsMetadata, c, longest);
+  message += formatHelpMessageOptions(optionsMetadata, c, longest);
 
   // CLI commands
-  msg += formatHelpMsgCommands(subcommandsMetadata, c, longest);
+  message += formatHelpMessageCommands(subcommandsMetadata, c, longest);
 
   // CLI arguments
-  msg += formatHelpMsgArguments(argsMetadata, c, longest);
+  message += formatHelpMessageArguments(argumentsMetadata, c, longest);
 
   // CLI example
   if (metadata.example) {
-    msg += formatTitle("Example");
-    msg += ln(1);
+    message += formatTitle("Example");
+    message += ln(1);
     const normalizeExample = metadata.example.replace(/\n+/g, "\n" + indent(3));
-    msg += concat(indent(2), c.example(normalizeExample), ln(2));
+    message += concat(indent(2), c.example(normalizeExample), ln(2));
   }
 
-  return msg;
+  return message;
 }
 
-export function formatSubcommandHelpMsg(subcommand: Subcommand, printStyle?: Partial<HelpMsgStyle>, cliName = "") {
-  const c = helpMsgStyles.default;
+export function formatSubcommandHelpMessage(
+  subcommand: Subcommand,
+  printStyle?: Partial<HelpMessageStyle>,
+  cliName = "",
+) {
+  const c = helpMessageStyles.default;
   if (printStyle) Object.assign(c, printStyle);
 
   const usage =
@@ -109,13 +129,13 @@ export function formatSubcommandHelpMsg(subcommand: Subcommand, printStyle?: Par
 
   const asCli: Cli = { cliName, usage, ...subcommand };
 
-  return formatCliHelpMsg([asCli], c);
+  return formatCliHelpMessage([asCli], c);
 }
 
-export function printCliHelp(params: readonly [Cli, ...Subcommand[]], style?: Partial<HelpMsgStyle>) {
-  console.log(formatCliHelpMsg(params, style));
+export function printCliHelp(parameters: readonly [Cli, ...Subcommand[]], style?: Partial<HelpMessageStyle>) {
+  console.log(formatCliHelpMessage(parameters, style));
 }
 
-export function printSubcommandHelp(subcommand: Subcommand, style?: Partial<HelpMsgStyle>, cliName = "") {
-  console.log(formatSubcommandHelpMsg(subcommand, style, cliName));
+export function printSubcommandHelp(subcommand: Subcommand, style?: Partial<HelpMessageStyle>, cliName = "") {
+  console.log(formatSubcommandHelpMessage(subcommand, style, cliName));
 }

package/src/help-message/format-options.ts

@@ -1,27 +1,34 @@
-import { concat, indent, insertAtEndOfFirstLine, ln } from "../utils.js";
+import { concat, indent, insertAtEndOfFirstLine, ln } from "../utilities.js";
 
 import type { OptionMetadata } from "../metadata/metadata-types.js";
-import type { HelpMsgStyle } from "../types.js";
+import type { HelpMessageStyle } from "../types.js";
 
-export function formatHelpMsgOptions(optionsMetadata: OptionMetadata[], c: HelpMsgStyle, longest: number): string {
-  if (!optionsMetadata.length) return "";
+export function formatHelpMessageOptions(
+  optionsMetadata: OptionMetadata[],
+  c: HelpMessageStyle,
+  longest: number,
+): string {
+  if (optionsMetadata.length === 0) return "";
 
-  let msg = c.title(" OPTIONS") + ln(1);
+  let message = c.title(" OPTIONS") + ln(1);
 
   for (const metadata of optionsMetadata) {
     const names = metadata.aliasesAsArgs.concat([metadata.nameAsArg]);
     const normalizeDesc = metadata.description.replace(/\n+/g, "\n" + indent(longest + 6) + c.punctuation("└"));
-    const defaultStr =
-      typeof metadata.defaultValue !== "undefined" ? `(default: ${metadata.defaultValueAsString})` : "";
+    const defaultString = metadata.defaultValue === undefined ? "" : `(default: ${metadata.defaultValueAsString})`;
 
     const optLength = names.join(", ").length + metadata.placeholder.length;
     const spacing = longest + 1 - optLength;
 
     const coloredNames = names.map(name => c.option(name)).join(c.punctuation(", "));
 
-    const defaultOrOptional = defaultStr ? c.default(defaultStr) : metadata.optional ? c.optional("(optional)") : "";
+    const defaultOrOptional = defaultString
+      ? c.default(defaultString)
+      : metadata.optional
+        ? c.optional("(optional)")
+        : "";
 
-    msg += concat(
+    message += concat(
       indent(2) + coloredNames,
       c.placeholder(metadata.placeholder),
       indent(spacing),
@@ -31,14 +38,14 @@ export function formatHelpMsgOptions(optionsMetadata: OptionMetadata[], c: HelpM
 
     if (metadata.example) {
       const normalizeExample = metadata.example.replace(/\n+/g, "\n" + indent(longest + 16));
-      msg += concat(
+      message += concat(
         indent(longest + 6) + c.punctuation("└") + c.exampleTitle("Example:"),
         c.example(normalizeExample) + ln(1),
       );
     }
   }
 
-  msg += ln(1);
+  message += ln(1);
 
-  return msg;
+  return message;
 }

package/src/help-message/format-subcommands.ts

@@ -1,16 +1,16 @@
-import { concat, indent, ln, subcommandPlaceholder } from "../utils.js";
+import { concat, indent, ln, subcommandPlaceholder } from "../utilities.js";
 
 import type { SubcommandMetadata } from "../metadata/metadata-types.js";
-import type { HelpMsgStyle } from "../types.js";
+import type { HelpMessageStyle } from "../types.js";
 
-export function formatHelpMsgCommands(
+export function formatHelpMessageCommands(
   subcommandsMetadata: SubcommandMetadata[],
-  c: HelpMsgStyle,
+  c: HelpMessageStyle,
   longest: number,
 ): string {
-  if (!subcommandsMetadata.length) return "";
+  if (subcommandsMetadata.length === 0) return "";
 
-  let msg = c.title(" COMMANDS") + ln(1);
+  let message = c.title(" COMMANDS") + ln(1);
 
   for (const metadata of subcommandsMetadata) {
     const names = metadata.aliases.concat([metadata.name]);
@@ -22,7 +22,7 @@ export function formatHelpMsgCommands(
 
     const coloredNames = names.map(name => c.command(name)).join(c.punctuation(", "));
 
-    msg += concat(
+    message += concat(
       indent(2) + coloredNames,
       c.placeholder(placeholder),
       indent(spacing),
@@ -30,7 +30,7 @@ export function formatHelpMsgCommands(
     );
   }
 
-  msg += ln(1);
+  message += ln(1);
 
-  return msg;
+  return message;
 }

package/src/help-message/styles.ts

@@ -1,7 +1,7 @@
 import chalk from "chalk";
-import type { HelpMsgStyle } from "../types.js";
+import type { HelpMessageStyle } from "../types.js";
 
-export const helpMsgStyles = Object.freeze({
+export const helpMessageStyles = Object.freeze({
   default: {
     title: chalk.bold.blue,
     description: chalk.white,
@@ -55,17 +55,17 @@ export const helpMsgStyles = Object.freeze({
     punctuation: chalk.hex("#4C566A"),
   },
   html: {
-    title: (...str) => `<span style="color: #89dceb; font-weight: bold;">${escapeHTML(str.join(" "))}</span>`,
-    description: (...str) => `<span style="color: #cdd6e8;">${escapeHTML(str.join(" "))}</span>`,
-    default: (...str) => `<span style="color: #6c7086; font-style: italic;">${escapeHTML(str.join(" "))}</span>`,
-    optional: (...str) => `<span style="color: #6c7086; font-style: italic;">${escapeHTML(str.join(" "))}</span>`,
-    exampleTitle: (...str) => `<span style="color: #f9e2af;">${escapeHTML(str.join(" "))}</span>`,
-    example: (...str) => `<span style="color: #6c7086;">${escapeHTML(str.join(" "))}</span>`,
-    command: (...str) => `<span style="color: #f9e2af;">${escapeHTML(str.join(" "))}</span>`,
-    option: (...str) => `<span style="color: #17b85d;">${escapeHTML(str.join(" "))}</span>`,
-    argument: (...str) => `<span style="color: #00ff00;">${escapeHTML(str.join(" "))}</span>`,
-    placeholder: (...str) => `<span style="color: #db9518;">${escapeHTML(str.join(" "))}</span>`,
-    punctuation: (...str) => `<span style="color: #6c7086;">${escapeHTML(str.join(" "))}</span>`,
+    title: (...string) => `<span style="color: #89dceb; font-weight: bold;">${escapeHTML(string.join(" "))}</span>`,
+    description: (...string) => `<span style="color: #cdd6e8;">${escapeHTML(string.join(" "))}</span>`,
+    default: (...string) => `<span style="color: #6c7086; font-style: italic;">${escapeHTML(string.join(" "))}</span>`,
+    optional: (...string) => `<span style="color: #6c7086; font-style: italic;">${escapeHTML(string.join(" "))}</span>`,
+    exampleTitle: (...string) => `<span style="color: #f9e2af;">${escapeHTML(string.join(" "))}</span>`,
+    example: (...string) => `<span style="color: #6c7086;">${escapeHTML(string.join(" "))}</span>`,
+    command: (...string) => `<span style="color: #f9e2af;">${escapeHTML(string.join(" "))}</span>`,
+    option: (...string) => `<span style="color: #17b85d;">${escapeHTML(string.join(" "))}</span>`,
+    argument: (...string) => `<span style="color: #00ff00;">${escapeHTML(string.join(" "))}</span>`,
+    placeholder: (...string) => `<span style="color: #db9518;">${escapeHTML(string.join(" "))}</span>`,
+    punctuation: (...string) => `<span style="color: #6c7086;">${escapeHTML(string.join(" "))}</span>`,
   },
   gruvboxDark: {
     title: chalk.bold.hex("#FABD2F"),
@@ -109,12 +109,12 @@ export const helpMsgStyles = Object.freeze({
   get noColors() {
     return new Proxy(this.default, {
       get() {
-        return (...str: string[]) => str.join(" ");
+        return (...string: string[]) => string.join(" ");
       },
-    });
+    }) as HelpMessageStyle;
   },
-}) satisfies Record<string, HelpMsgStyle>;
+}) satisfies Record<string, HelpMessageStyle>;
 
-function escapeHTML(str: string) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function escapeHTML(string: string) {
+  return string.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 import type {
-  ActionsFn,
+  ActionsFunctions,
   Argument,
   CheckArgumentsOptional,
   CheckDuplicatedArguments,
@@ -17,45 +17,45 @@ import type {
  * - Insures no optional arguments are allowed when `allowPositional` is enabled
  */
 type CheckCliSubcommandInput<T extends Cli | Subcommand> =
-  CheckDuplicatedOptions<T> extends infer Err extends string
-    ? Err
-    : CheckDuplicatedArguments<T> extends infer Err extends string
-      ? Err
-      : CheckArgumentsOptional<T> extends infer Err extends string
-        ? Err
+  CheckDuplicatedOptions<T> extends infer Error extends string
+    ? Error
+    : CheckDuplicatedArguments<T> extends infer Error extends string
+      ? Error
+      : CheckArgumentsOptional<T> extends infer Error extends string
+        ? Error
         : T;
 
 export function createCli<const T extends Cli>(input: CheckCliSubcommandInput<T>) {
-  const setAction = (action: (res: any) => any) => {
+  const setAction = (action: (data: any) => any) => {
     if (typeof input === "string") return;
     input.action = action;
   };
 
-  const setPreValidationHook = (hook: (ctx: any) => any) => {
+  const setPreValidationHook = (hook: (context: any) => any) => {
     if (typeof input === "string") return;
     input.preValidation = hook;
   };
 
-  return Object.assign(input, { setAction, setPreValidationHook }) as Prettify<typeof input & ActionsFn<T>>;
+  return Object.assign(input, { setAction, setPreValidationHook }) as Prettify<typeof input & ActionsFunctions<T>>;
 }
 
 export function createSubcommand<const T extends Subcommand>(input: CheckCliSubcommandInput<T>) {
-  const setAction = (action: (res: any) => any) => {
+  const setAction = (action: (data: any) => any) => {
     if (typeof input === "string") return;
     input.action = action as T["action"];
   };
 
-  const setPreValidationHook = (hook: (ctx: any) => any) => {
+  const setPreValidationHook = (hook: (context: any) => any) => {
     if (typeof input === "string") return;
     input.preValidation = hook;
   };
 
-  return Object.assign(input, { setAction, setPreValidationHook }) as Prettify<typeof input & ActionsFn<T>>;
+  return Object.assign(input, { setAction, setPreValidationHook }) as Prettify<typeof input & ActionsFunctions<T>>;
 }
 
 /** - Insures that there are no duplicated options */
 type CheckOptionsInput<T extends Option[]> =
-  CheckDuplicatedOptions<{ options: T }> extends infer Err extends string ? Err : T;
+  CheckDuplicatedOptions<{ options: T }> extends infer Error extends string ? Error : T;
 
 export function createOptions<const T extends [Option, ...Option[]]>(options: CheckOptionsInput<T>) {
   return options;
@@ -63,24 +63,24 @@ export function createOptions<const T extends [Option, ...Option[]]>(options: Ch
 
 /** - Insures that only the last argument is optional */
 type CheckArgumentsInput<T extends Argument[]> =
-  CheckArgumentsOptional<{ arguments: T }> extends infer Err extends string ? Err : T;
+  CheckArgumentsOptional<{ arguments: T }> extends infer Error extends string ? Error : T;
 
-export function createArguments<const T extends [Argument, ...Argument[]]>(args: CheckArgumentsInput<T>) {
-  return args;
+export function createArguments<const T extends [Argument, ...Argument[]]>(arguments_: CheckArgumentsInput<T>) {
+  return arguments_;
 }
 
 export {
-  formatCliHelpMsg,
-  formatSubcommandHelpMsg,
+  formatCliHelpMessage as formatCliHelpMsg,
+  formatSubcommandHelpMessage as formatSubcommandHelpMsg,
   printCliHelp,
   printSubcommandHelp,
 } from "./help-message/format-cli.js";
-export { helpMsgStyles } from "./help-message/styles.js";
+export { helpMessageStyles } from "./help-message/styles.js";
 
 export { safeParse, safeParseAsync } from "./parser/safe-parse.js";
 export { unsafeParse as parse, unsafeParseAsync as parseAsync } from "./parser/unsafe-parse.js";
 
-export { isOptionalSchema, schemaDefaultValue, stringToArray, stringToSet } from "./zod-utils.js";
+export { isOptionalSchema, schemaDefaultValue, stringToArray, stringToSet } from "./zod-utilities.js";
 
 export { generateBashAutocompleteScript } from "./autocomplete-scripts/bash-autocomplete-script.js";
 export { generatePowerShellAutocompleteScript } from "./autocomplete-scripts/powershell-autocomplete-script.js";