123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
import { getDefaultValue, getOption, paramCaseToCamelCase } from "./_utils.ts";import {  ArgumentFollowsVariadicArgument,  DuplicateOption,  InvalidOptionValue,  MissingOptionValue,  RequiredArgumentFollowsOptionalArgument,  UnknownConflictingOption,  UnknownOption,  UnknownRequiredOption,  UnknownType,} from "./_errors.ts";import { normalize } from "./normalize.ts";import type {  IFlagArgument,  IFlagOptions,  IFlagsResult,  IParseOptions,  ITypeHandler,} from "./types.ts";import { OptionType } from "./types.ts";import { boolean } from "./types/boolean.ts";import { number } from "./types/number.ts";import { string } from "./types/string.ts";import { validateFlags } from "./validate_flags.ts";import { integer } from "./types/integer.ts";
const Types: Record<string, ITypeHandler<unknown>> = {  [OptionType.STRING]: string,  [OptionType.NUMBER]: number,  [OptionType.INTEGER]: integer,  [OptionType.BOOLEAN]: boolean,};
/** * Parse command line arguments. * @param args  Command line arguments e.g: `Deno.args` * @param opts  Parse options. * ``` * // example.ts -x 3 -y.z -n5 -abc --beep=boop foo bar baz --deno.land -- --cliffy * parseFlags(Deno.args); * ``` * ``` * { *   flags: { *     x: "3", *     y: { z: true }, *     n: "5", *     a: true, *     b: true, *     c: true, *     beep: "boop", *     deno: { land: true } *   }, *   unknown: [ "foo", "bar", "baz" ], *   literal: [ "--cliffy" ] * } * ``` */// deno-lint-ignore no-explicit-anyexport function parseFlags<O extends Record<string, any> = Record<string, any>>(  args: string[],  opts: IParseOptions = {},): IFlagsResult<O> {  !opts.flags && (opts.flags = []);
  const normalized = normalize(args);
  let inLiteral = false;  let negate = false;
  const flags: Record<string, unknown> = {};  const optionNames: Record<string, string> = {};  let literal: string[] = [];  let unknown: string[] = [];  let stopEarly: string | null = null;
  opts.flags.forEach((opt) => {    opt.depends?.forEach((flag) => {      if (!opts.flags || !getOption(opts.flags, flag)) {        throw new UnknownRequiredOption(flag, opts.flags ?? []);      }    });    opt.conflicts?.forEach((flag) => {      if (!opts.flags || !getOption(opts.flags, flag)) {        throw new UnknownConflictingOption(flag, opts.flags ?? []);      }    });  });
  for (let i = 0; i < normalized.length; i++) {    let option: IFlagOptions | undefined;    let args: IFlagArgument[] | undefined;    const current = normalized[i];
    // literal args after --    if (inLiteral) {      literal.push(current);      continue;    }
    if (current === "--") {      inLiteral = true;      continue;    }
    const isFlag = current.length > 1 && current[0] === "-";    const next = () => normalized[i + 1];
    if (isFlag) {      if (current[2] === "-" || (current[1] === "-" && current.length === 3)) {        throw new UnknownOption(current, opts.flags);      }
      negate = current.startsWith("--no-");
      option = getOption(opts.flags, current);      // if (option && negate) {      //   const positiveName: string = current.replace(/^-+(no-)?/, "");      //   option = getOption(opts.flags, positiveName) ?? option;      // }
      if (!option) {        if (opts.flags.length) {          throw new UnknownOption(current, opts.flags);        }
        option = {          name: current.replace(/^-+/, ""),          optionalValue: true,          type: OptionType.STRING,        };      }
      const positiveName: string = option.name.replace(/^no-?/, "");      const propName: string = paramCaseToCamelCase(positiveName);
      if (typeof flags[propName] !== "undefined" && !option.collect) {        throw new DuplicateOption(current);      }
      args = option.args?.length ? option.args : [{        type: option.type,        requiredValue: option.requiredValue,        optionalValue: option.optionalValue,        variadic: option.variadic,        list: option.list,        separator: option.separator,      }];
      let argIndex = 0;      let inOptionalArg = false;      const previous = flags[propName];
      parseNext(option, args);
      if (typeof flags[propName] === "undefined") {        if (typeof option.default !== "undefined") {          flags[propName] = getDefaultValue(option);        } else if (args[argIndex].requiredValue) {          throw new MissingOptionValue(option.name);        } else {          flags[propName] = true;        }      }
      if (option.value) {        flags[propName] = option.value(flags[propName], previous);      } else if (option.collect) {        const value: unknown[] = Array.isArray(previous) ? previous : [];        value.push(flags[propName]);        flags[propName] = value;      }
      optionNames[propName] = option.name;
      opts.option?.(option, flags[propName]);
      /** Parse next argument for current option. */      // deno-lint-ignore no-inner-declarations      function parseNext(option: IFlagOptions, args: IFlagArgument[]): void {        const arg: IFlagArgument = args[argIndex];
        if (!arg) {          const flag = next();          throw new UnknownOption(flag, opts.flags ?? []);        }
        if (!arg.type) {          arg.type = OptionType.BOOLEAN;        }
        if (option.args?.length) {          // make all value's required per default          if (            (typeof arg.optionalValue === "undefined" ||              arg.optionalValue === false) &&            typeof arg.requiredValue === "undefined"          ) {            arg.requiredValue = true;          }        } else {          // make non boolean value required per default          if (            arg.type !== OptionType.BOOLEAN &&            (typeof arg.optionalValue === "undefined" ||              arg.optionalValue === false) &&            typeof arg.requiredValue === "undefined"          ) {            arg.requiredValue = true;          }        }
        if (arg.requiredValue) {          if (inOptionalArg) {            throw new RequiredArgumentFollowsOptionalArgument(option.name);          }        } else {          inOptionalArg = true;        }
        if (negate) {          flags[propName] = false;          return;        }
        let result: unknown;        let increase = false;
        if (arg.list && hasNext(arg)) {          const parsed: unknown[] = next()            .split(arg.separator || ",")            .map((nextValue: string) => {              const value = parseValue(option, arg, nextValue);              if (typeof value === "undefined") {                throw new InvalidOptionValue(                  option.name,                  arg.type ?? "?",                  nextValue,                );              }              return value;            });
          if (parsed?.length) {            result = parsed;          }        } else {          if (hasNext(arg)) {            result = parseValue(option, arg, next());          } else if (arg.optionalValue && arg.type === OptionType.BOOLEAN) {            result = true;          }        }
        if (increase) {          i++;          if (!arg.variadic) {            argIndex++;          } else if (args[argIndex + 1]) {            throw new ArgumentFollowsVariadicArgument(next());          }        }
        if (          typeof result !== "undefined" && ((args.length > 1) || arg.variadic)        ) {          if (!flags[propName]) {            flags[propName] = [];          }
          (flags[propName] as Array<unknown>).push(result);
          if (hasNext(arg)) {            parseNext(option, args);          }        } else {          flags[propName] = result;        }
        /** Check if current option should have an argument. */        function hasNext(arg: IFlagArgument): boolean {          return !!(            normalized[i + 1] &&            (arg.optionalValue || arg.requiredValue || arg.variadic) &&            (normalized[i + 1][0] !== "-" ||              (arg.type === OptionType.NUMBER &&                !isNaN(Number(normalized[i + 1])))) &&            arg          );        }
        /** Parse argument value.  */        function parseValue(          option: IFlagOptions,          arg: IFlagArgument,          value: string,        ): unknown {          const type: string = arg.type || OptionType.STRING;          const result: unknown = opts.parse            ? opts.parse({              label: "Option",              type,              name: `--${option.name}`,              value,            })            : parseFlagValue(option, arg, value);
          if (typeof result !== "undefined") {            increase = true;          }
          return result;        }      }    } else {      if (opts.stopEarly) {        stopEarly = current;        break;      }      unknown.push(current);    }  }
  if (stopEarly) {    const stopEarlyArgIndex: number = args.indexOf(stopEarly);    if (stopEarlyArgIndex !== -1) {      const doubleDashIndex: number = args.indexOf("--");      unknown = args.slice(        stopEarlyArgIndex,        doubleDashIndex === -1 ? undefined : doubleDashIndex,      );      if (doubleDashIndex !== -1) {        literal = args.slice(doubleDashIndex + 1);      }    }  }
  if (opts.flags?.length) {    validateFlags(      opts.flags,      flags,      opts.knownFlaks,      opts.allowEmpty,      optionNames,    );  }
  // convert dotted option keys into nested objects  const result = Object.keys(flags)    .reduce((result: Record<string, unknown>, key: string) => {      if (~key.indexOf(".")) {        key.split(".").reduce(          (            // deno-lint-ignore no-explicit-any            result: Record<string, any>,            subKey: string,            index: number,            parts: string[],          ) => {            if (index === parts.length - 1) {              result[subKey] = flags[key];            } else {              result[subKey] = result[subKey] ?? {};            }            return result[subKey];          },          result,        );      } else {        result[key] = flags[key];      }      return result;    }, {});
  return { flags: result as O, unknown, literal };}
function parseFlagValue(  option: IFlagOptions,  arg: IFlagArgument,  value: string,): unknown {  const type: string = arg.type || OptionType.STRING;  const parseType = Types[type];
  if (!parseType) {    throw new UnknownType(type, Object.keys(Types));  }
  return parseType({    label: "Option",    type,    name: `--${option.name}`,    value,  });}