123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410
import { getFlag } from "../../flags/_utils.ts";import { Table } from "../../table/table.ts";import { dedent, getDescription, parseArgumentsDefinition } from "../_utils.ts";import type { Command } from "../command.ts";import {  blue,  bold,  dim,  getColorEnabled,  green,  italic,  magenta,  red,  setColorEnabled,  yellow,} from "../deps.ts";import { Type } from "../type.ts";import type { Argument, EnvVar, Example, Option } from "../types.ts";
export interface HelpOptions {  types?: boolean;  hints?: boolean;  colors?: boolean;  long?: boolean;}
interface OptionGroup {  name?: string;  options: Array<Option>;}
/** Help text generator. */export class HelpGenerator {  private indent = 2;  private options: Required<HelpOptions>;
  /** Generate help text for given command. */  public static generate(cmd: Command, options?: HelpOptions): string {    return new HelpGenerator(cmd, options).generate();  }
  private constructor(    private cmd: Command,    options: HelpOptions = {},  ) {    this.options = {      types: false,      hints: true,      colors: true,      long: false,      ...options,    };  }
  private generate(): string {    const areColorsEnabled = getColorEnabled();    setColorEnabled(this.options.colors);
    const result = this.generateHeader() +      this.generateMeta() +      this.generateDescription() +      this.generateOptions() +      this.generateCommands() +      this.generateEnvironmentVariables() +      this.generateExamples();
    setColorEnabled(areColorsEnabled);
    return result;  }
  private generateHeader(): string {    const usage = this.cmd.getUsage();    const rows = [      [        bold("Usage:"),        magenta(          this.cmd.getPath() +            (usage ? " " + highlightArguments(usage, this.options.types) : ""),        ),      ],    ];    const version: string | undefined = this.cmd.getVersion();    if (version) {      rows.push([bold("Version:"), yellow(`${this.cmd.getVersion()}`)]);    }    return "\n" +      Table.from(rows)        .indent(this.indent)        .padding(1)        .toString() +      "\n";  }
  private generateMeta(): string {    const meta = Object.entries(this.cmd.getMeta());    if (!meta.length) {      return "";    }
    const rows = [];    for (const [name, value] of meta) {      rows.push([bold(`${name}: `) + value]);    }
    return "\n" +      Table.from(rows)        .indent(this.indent)        .padding(1)        .toString() +      "\n";  }
  private generateDescription(): string {    if (!this.cmd.getDescription()) {      return "";    }    return this.label("Description") +      Table.from([        [dedent(this.cmd.getDescription())],      ])        .indent(this.indent * 2)        .maxColWidth(140)        .padding(1)        .toString() +      "\n";  }
  private generateOptions(): string {    const options = this.cmd.getOptions(false);    if (!options.length) {      return "";    }
    let groups: Array<OptionGroup> = [];    const hasGroups = options.some((option) => option.groupName);    if (hasGroups) {      for (const option of options) {        let group = groups.find((group) => group.name === option.groupName);        if (!group) {          group = {            name: option.groupName,            options: [],          };          groups.push(group);        }        group.options.push(option);      }    } else {      groups = [{        name: "Options",        options,      }];    }
    let result = "";    for (const group of groups) {      result += this.generateOptionGroup(group);    }
    return result;  }
  private generateOptionGroup(group: OptionGroup): string {    if (!group.options.length) {      return "";    }    const hasTypeDefinitions = !!group.options.find((option) =>      !!option.typeDefinition    );
    if (hasTypeDefinitions) {      return this.label(group.name ?? "Options") +        Table.from([          ...group.options.map((option: Option) => [            option.flags.map((flag) => blue(flag)).join(", "),            highlightArguments(              option.typeDefinition || "",              this.options.types,            ),            red(bold("-")),            getDescription(option.description, !this.options.long),            this.generateHints(option),          ]),        ])          .padding([2, 2, 1, 2])          .indent(this.indent * 2)          .maxColWidth([60, 60, 1, 80, 60])          .toString() +        "\n";    }
    return this.label(group.name ?? "Options") +      Table.from([        ...group.options.map((option: Option) => [          option.flags.map((flag) => blue(flag)).join(", "),          red(bold("-")),          getDescription(option.description, !this.options.long),          this.generateHints(option),        ]),      ])        .indent(this.indent * 2)        .maxColWidth([60, 1, 80, 60])        .padding([2, 1, 2])        .toString() +      "\n";  }
  private generateCommands(): string {    const commands = this.cmd.getCommands(false);    if (!commands.length) {      return "";    }
    const hasTypeDefinitions = !!commands.find((command) =>      !!command.getArgsDefinition()    );
    if (hasTypeDefinitions) {      return this.label("Commands") +        Table.from([          ...commands.map((command: Command) => [            [command.getName(), ...command.getAliases()].map((name) =>              blue(name)            ).join(", "),            highlightArguments(              command.getArgsDefinition() || "",              this.options.types,            ),            red(bold("-")),            command.getShortDescription(),          ]),        ])          .indent(this.indent * 2)          .maxColWidth([60, 60, 1, 80])          .padding([2, 2, 1, 2])          .toString() +        "\n";    }
    return this.label("Commands") +      Table.from([        ...commands.map((command: Command) => [          [command.getName(), ...command.getAliases()].map((name) => blue(name))            .join(", "),          red(bold("-")),          command.getShortDescription(),        ]),      ])        .maxColWidth([60, 1, 80])        .padding([2, 1, 2])        .indent(this.indent * 2)        .toString() +      "\n";  }
  private generateEnvironmentVariables(): string {    const envVars = this.cmd.getEnvVars(false);    if (!envVars.length) {      return "";    }    return this.label("Environment variables") +      Table.from([        ...envVars.map((envVar: EnvVar) => [          envVar.names.map((name: string) => blue(name)).join(", "),          highlightArgumentDetails(            envVar.details,            this.options.types,          ),          red(bold("-")),          this.options.long            ? dedent(envVar.description)            : envVar.description.trim().split("\n", 1)[0],          envVar.required ? `(${yellow(`required`)})` : "",        ]),      ])        .padding([2, 2, 1, 2])        .indent(this.indent * 2)        .maxColWidth([60, 60, 1, 80, 10])        .toString() +      "\n";  }
  private generateExamples(): string {    const examples = this.cmd.getExamples();    if (!examples.length) {      return "";    }    return this.label("Examples") +      Table.from(examples.map((example: Example) => [        dim(bold(`${capitalize(example.name)}:`)),        dedent(example.description),      ]))        .padding(1)        .indent(this.indent * 2)        .maxColWidth(150)        .toString() +      "\n";  }
  private generateHints(option: Option): string {    if (!this.options.hints) {      return "";    }    const hints = [];
    option.required && hints.push(yellow(`required`));    typeof option.default !== "undefined" && hints.push(      bold(`Default: `) + inspect(option.default, this.options.colors),    );    option.depends?.length && hints.push(      yellow(bold(`Depends: `)) +        italic(option.depends.map(getFlag).join(", ")),    );    option.conflicts?.length && hints.push(      red(bold(`Conflicts: `)) +        italic(option.conflicts.map(getFlag).join(", ")),    );
    const type = this.cmd.getType(option.args[0]?.type)?.handler;    if (type instanceof Type) {      const possibleValues = type.values?.(this.cmd, this.cmd.getParent());      if (possibleValues?.length) {        hints.push(          bold(`Values: `) +            possibleValues.map((value: unknown) =>              inspect(value, this.options.colors)            ).join(", "),        );      }    }
    if (hints.length) {      return `(${hints.join(", ")})`;    }
    return "";  }
  private label(label: string) {    return "\n" +      " ".repeat(this.indent) + bold(`${label}:`) +      "\n\n";  }}
function capitalize(string: string): string {  return string?.charAt(0).toUpperCase() + string.slice(1) ?? "";}
function inspect(value: unknown, colors: boolean): string {  return Deno.inspect(    value,    // deno < 1.4.3 doesn't support the colors property.    { depth: 1, colors, trailingComma: false } as Deno.InspectOptions,  );}
/** * Colorize arguments string. * @param argsDefinition Arguments definition: `<color1:string> <color2:string>` * @param types Show types. */function highlightArguments(argsDefinition: string, types = true) {  if (!argsDefinition) {    return "";  }
  return parseArgumentsDefinition(argsDefinition, false, true)    .map((arg: Argument | string) =>      typeof arg === "string" ? arg : highlightArgumentDetails(arg, types)    )    .join(" ");}
/** * Colorize argument string. * @param arg Argument details. * @param types Show types. */function highlightArgumentDetails(  arg: Argument,  types = true,): string {  let str = "";
  str += yellow(arg.optionalValue ? "[" : "<");
  let name = "";  name += arg.name;  if (arg.variadic) {    name += "...";  }  name = magenta(name);
  str += name;
  if (types) {    str += yellow(":");    str += red(arg.type);    if (arg.list) {      str += green("[]");    }  }
  str += yellow(arg.optionalValue ? "]" : ">");
  return str;}