args-json/index.ts

Zero-dependency descriptively typed command-line argument parser

export type ArgMap = Record<string, string>;

function toCamelCase(x: string): string {
  let s = x.replace(/^[-_.\s~+]|[-_.\s~+]$/g, "");

  if (!/[-_.\s~+]/.test(s)) return s.slice(0, 1).toLowerCase() + s.slice(1);

  return s
    .toLowerCase()
    .replace(/[-_.\s~+](\S)/g, (_, match) => match.toUpperCase());
}

function toKey(x: string | undefined): string | undefined {
  if (x) {
    if (x.startsWith("--") && x.length > 2) return toCamelCase(x.slice(2));
    if (x.startsWith("-") && x.length === 2) return toCamelCase(x.slice(1));
  }
}

function split(x: string): string[] {
  let words: string[] = [],
    word = "";

  let hasOpenSingleQuote = false;
  let hasOpenDoubleQuote = false;

  for (let i = 0; i < x.length; i++) {
    let c = x[i];

    if (/^\s/.test(c) && !hasOpenSingleQuote && !hasOpenDoubleQuote) {
      if (word) words.push(word);
      word = "";
      continue;
    }

    if (c === "'" && x[i - 1] !== "\\")
      hasOpenSingleQuote = !hasOpenSingleQuote;

    if (c === '"' && x[i - 1] !== "\\")
      hasOpenDoubleQuote = !hasOpenDoubleQuote;

    word += c;
  }

  if (word) words.push(word);

  return words;
}

function getDefaultInput(): string[] {
  return typeof process === "undefined" ? [] : process.argv;
}

export function parseArgs<
  T extends Record<string, unknown> = Record<string, unknown>,
>(map?: ArgMap): T;

export function parseArgs<
  T extends Record<string, unknown> = Record<string, unknown>,
>(input?: string | string[], map?: ArgMap): T;

export function parseArgs<
  T extends Record<string, unknown> = Record<string, unknown>,
>(input?: string | string[] | ArgMap, map?: ArgMap): T {
  let normalizedInput: string[];
  let normalizedMap: ArgMap | undefined;

  if (input === undefined) normalizedInput = getDefaultInput();
  else if (typeof input === "string") normalizedInput = split(input);
  else if (Array.isArray(input)) normalizedInput = input.map((x) => String(x));
  else if (input !== null && typeof input === "object") {
    normalizedInput = getDefaultInput();
    normalizedMap = input;
  } else normalizedInput = [];

  normalizedInput = normalizedInput.flatMap((item) => {
    let normalizedItem = item.trim();
    let k = normalizedItem.indexOf("=");

    if (k === -1) return normalizedItem;

    return [normalizedItem.slice(0, k), normalizedItem.slice(k + 1)];
  });

  if (map) normalizedMap = map;

  let key = "";
  let parsedArgs: Record<string, unknown> = {};

  for (let rawValue of normalizedInput) {
    rawValue = rawValue.trim();

    if (rawValue.startsWith('"') && rawValue.endsWith('"'))
      rawValue = rawValue.slice(1, -1);
    else if (rawValue.startsWith("'") && rawValue.endsWith("'"))
      rawValue = rawValue.slice(1, -1);

    let parsedKey = toKey(rawValue);

    if (parsedKey !== undefined) {
      let nextKey = normalizedMap?.[parsedKey] ?? parsedKey;

      if (key && nextKey !== key && parsedArgs[key] === undefined)
        parsedArgs[key] = true;

      key = nextKey;
      continue;
    }

    let parsedValue: unknown;

    if (rawValue) {
      try {
        parsedValue = JSON.parse(rawValue);
      } catch {
        parsedValue = rawValue;
      }
    } else parsedValue = true;

    let prevValue = parsedArgs[key];
    let value: unknown;

    if (prevValue === undefined)
      value = key === "" ? [parsedValue] : parsedValue;
    else if (Array.isArray(prevValue)) value = [...prevValue, parsedValue];
    else value = [prevValue, parsedValue];

    parsedArgs[key] = value;
  }

  if (key && parsedArgs[key] === undefined) parsedArgs[key] = true;

  return parsedArgs as T;
}