import { assert } from "../_util/assert.ts";
type Id<T> = T extends Record<string, unknown> ? T extends infer U ? { [K in keyof U]: Id<U[K]> } : never : T;
type UnionToIntersection<T> = (T extends unknown ? (args: T) => unknown : never) extends (args: infer R) => unknown ? R extends Record<string, unknown> ? R : never : never;
type BooleanType = boolean | string | undefined;type StringType = string | undefined;type ArgType = StringType | BooleanType;
type Collectable = string | undefined;type Negatable = string | undefined;
type UseTypes< B extends BooleanType, S extends StringType, C extends Collectable,> = undefined extends ( & (false extends B ? undefined : B) & C & S) ? false : true;
type Values< B extends BooleanType, S extends StringType, C extends Collectable, N extends Negatable, D extends Record<string, unknown> | undefined, A extends Aliases | undefined,> = UseTypes<B, S, C> extends true ? & Record<string, unknown> & AddAliases< SpreadDefaults< & CollectValues<S, string, C, N> & RecursiveRequired<CollectValues<B, boolean, C>> & CollectUnknownValues<B, S, C, N>, DedotRecord<D> >, A > : Record<string, any>;
type Aliases<T = string, V extends string = string> = Partial< Record<Extract<T, string>, V | ReadonlyArray<V>>>;
type AddAliases< T, A extends Aliases | undefined,> = { [K in keyof T as AliasName<K, A>]: T[K] };
type AliasName< K, A extends Aliases | undefined,> = K extends keyof A ? string extends A[K] ? K : A[K] extends string ? K | A[K] : K : K;
type SpreadDefaults<A, D> = D extends undefined ? A : A extends Record<string, unknown> ? & Omit<A, keyof D> & { [K in keyof D]: K extends keyof A ? (A[K] & D[K] | D[K]) extends Record<string, unknown> ? NonNullable<SpreadDefaults<A[K], D[K]>> : D[K] | NonNullable<A[K]> : unknown; } : never;
type Defaults<B extends BooleanType, S extends StringType> = Id< UnionToIntersection< & Record<string, unknown> & MapTypes<S, unknown> & MapTypes<B, unknown> & MapDefaults<B> & MapDefaults<S> >>;
type MapDefaults<T extends ArgType> = Partial< Record<T extends string ? T : string, unknown>>;
type RecursiveRequired<T> = T extends Record<string, unknown> ? { [K in keyof T]-?: RecursiveRequired<T[K]>; } : T;
type CollectValues< T extends ArgType, V, C extends Collectable, N extends Negatable = undefined,> = UnionToIntersection< C extends string ? & MapTypes<Exclude<T, C>, V, N> & (T extends undefined ? Record<never, never> : RecursiveRequired< MapTypes<Extract<C, T>, Array<V>, N> >) : MapTypes<T, V, N>>;
type MapTypes<T extends ArgType, V, N extends Negatable = undefined> = undefined extends T ? Record<never, never> : T extends `${infer Name}.${infer Rest}` ? { [K in Name]?: MapTypes< Rest, V, N extends `${Name}.${infer Negate}` ? Negate : undefined >; } : T extends string ? Partial<Record<T, N extends T ? V | false : V>> : Record<never, never>;
type CollectUnknownValues< B extends BooleanType, S extends StringType, C extends Collectable, N extends Negatable,> = B & S extends C ? Record<never, never> : DedotRecord< & Record< Exclude< Extract<Exclude<C, N>, string>, Extract<S | B, string> >, Array<unknown> > & Record< Exclude< Extract<Extract<C, N>, string>, Extract<S | B, string> >, Array<unknown> | false > >;
type DedotRecord<T> = Record<string, unknown> extends T ? T : T extends Record<string, unknown> ? UnionToIntersection< ValueOf< { [K in keyof T]: K extends string ? Dedot<K, T[K]> : never } > > : T;
type Dedot<T extends string, V> = T extends `${infer Name}.${infer Rest}` ? { [K in Name]: Dedot<Rest, V> } : { [K in T]: V };
type ValueOf<T> = T[keyof T];
export type Args< A extends Record<string, unknown> = Record<string, any>, DD extends boolean | undefined = undefined,> = Id< & A & { _: Array<string | number>; } & (boolean extends DD ? DoubleDash : true extends DD ? Required<DoubleDash> : Record<never, never>)>;
type DoubleDash = { "--"?: Array<string>;};
export interface ParseOptions< B extends BooleanType = BooleanType, S extends StringType = StringType, C extends Collectable = Collectable, N extends Negatable = Negatable, D extends Record<string, unknown> | undefined = | Record<string, unknown> | undefined, A extends Aliases<string, string> | undefined = | Aliases<string, string> | undefined, DD extends boolean | undefined = boolean | undefined,> { "--"?: DD;
alias?: A;
boolean?: B | ReadonlyArray<Extract<B, string>>;
default?: D & Defaults<B, S>;
stopEarly?: boolean;
string?: S | ReadonlyArray<Extract<S, string>>;
collect?: C | ReadonlyArray<Extract<C, string>>;
negatable?: N | ReadonlyArray<Extract<N, string>>;
unknown?: (arg: string, key?: string, value?: unknown) => unknown;}
interface Flags { bools: Record<string, boolean>; strings: Record<string, boolean>; collect: Record<string, boolean>; negatable: Record<string, boolean>; unknownFn: (arg: string, key?: string, value?: unknown) => unknown; allBools: boolean;}
interface NestedMapping { [key: string]: NestedMapping | unknown;}
const { hasOwn } = Object;
function get<T>(obj: Record<string, T>, key: string): T | undefined { if (hasOwn(obj, key)) { return obj[key]; }}
function getForce<T>(obj: Record<string, T>, key: string): T { const v = get(obj, key); assert(v != null); return v;}
function isNumber(x: unknown): boolean { if (typeof x === "number") return true; if (/^0x[0-9a-f]+$/i.test(String(x))) return true; return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(String(x));}
function hasKey(obj: NestedMapping, keys: string[]): boolean { let o = obj; keys.slice(0, -1).forEach((key) => { o = (get(o, key) ?? {}) as NestedMapping; });
const key = keys[keys.length - 1]; return hasOwn(o, key);}
export function parse< V extends Values<B, S, C, N, D, A>, DD extends boolean | undefined = undefined, B extends BooleanType = undefined, S extends StringType = undefined, C extends Collectable = undefined, N extends Negatable = undefined, D extends Record<string, unknown> | undefined = undefined, A extends Aliases<AK, AV> | undefined = undefined, AK extends string = string, AV extends string = string,>( args: string[], { "--": doubleDash = false, alias = {} as NonNullable<A>, boolean = false, default: defaults = {} as D & Defaults<B, S>, stopEarly = false, string = [], collect = [], negatable = [], unknown = (i: string): unknown => i, }: ParseOptions<B, S, C, N, D, A, DD> = {},): Args<V, DD> { const aliases: Record<string, string[]> = {}; const flags: Flags = { bools: {}, strings: {}, unknownFn: unknown, allBools: false, collect: {}, negatable: {}, };
if (alias !== undefined) { for (const key in alias) { const val = getForce(alias, key); if (typeof val === "string") { aliases[key] = [val]; } else { aliases[key] = val as Array<string>; } for (const alias of getForce(aliases, key)) { aliases[alias] = [key].concat(aliases[key].filter((y) => alias !== y)); } } }
if (boolean !== undefined) { if (typeof boolean === "boolean") { flags.allBools = !!boolean; } else { const booleanArgs: ReadonlyArray<string> = typeof boolean === "string" ? [boolean] : boolean;
for (const key of booleanArgs.filter(Boolean)) { flags.bools[key] = true; const alias = get(aliases, key); if (alias) { for (const al of alias) { flags.bools[al] = true; } } } } }
if (string !== undefined) { const stringArgs: ReadonlyArray<string> = typeof string === "string" ? [string] : string;
for (const key of stringArgs.filter(Boolean)) { flags.strings[key] = true; const alias = get(aliases, key); if (alias) { for (const al of alias) { flags.strings[al] = true; } } } }
if (collect !== undefined) { const collectArgs: ReadonlyArray<string> = typeof collect === "string" ? [collect] : collect;
for (const key of collectArgs.filter(Boolean)) { flags.collect[key] = true; const alias = get(aliases, key); if (alias) { for (const al of alias) { flags.collect[al] = true; } } } }
if (negatable !== undefined) { const negatableArgs: ReadonlyArray<string> = typeof negatable === "string" ? [negatable] : negatable;
for (const key of negatableArgs.filter(Boolean)) { flags.negatable[key] = true; const alias = get(aliases, key); if (alias) { for (const al of alias) { flags.negatable[al] = true; } } } }
const argv: Args = { _: [] };
function argDefined(key: string, arg: string): boolean { return ( (flags.allBools && /^--[^=]+$/.test(arg)) || get(flags.bools, key) || !!get(flags.strings, key) || !!get(aliases, key) ); }
function setKey( obj: NestedMapping, name: string, value: unknown, collect = true, ) { let o = obj; const keys = name.split("."); keys.slice(0, -1).forEach(function (key) { if (get(o, key) === undefined) { o[key] = {}; } o = get(o, key) as NestedMapping; });
const key = keys[keys.length - 1]; const collectable = collect && !!get(flags.collect, name);
if (!collectable) { o[key] = value; } else if (get(o, key) === undefined) { o[key] = [value]; } else if (Array.isArray(get(o, key))) { (o[key] as unknown[]).push(value); } else { o[key] = [get(o, key), value]; } }
function setArg( key: string, val: unknown, arg: string | undefined = undefined, collect?: boolean, ) { if (arg && flags.unknownFn && !argDefined(key, arg)) { if (flags.unknownFn(arg, key, val) === false) return; }
const value = !get(flags.strings, key) && isNumber(val) ? Number(val) : val; setKey(argv, key, value, collect);
const alias = get(aliases, key); if (alias) { for (const x of alias) { setKey(argv, x, value, collect); } } }
function aliasIsBoolean(key: string): boolean { return getForce(aliases, key).some( (x) => typeof get(flags.bools, x) === "boolean", ); }
let notFlags: string[] = [];
if (args.includes("--")) { notFlags = args.slice(args.indexOf("--") + 1); args = args.slice(0, args.indexOf("--")); }
for (let i = 0; i < args.length; i++) { const arg = args[i];
if (/^--.+=/.test(arg)) { const m = arg.match(/^--([^=]+)=(.*)$/s); assert(m != null); const [, key, value] = m;
if (flags.bools[key]) { const booleanValue = value !== "false"; setArg(key, booleanValue, arg); } else { setArg(key, value, arg); } } else if ( /^--no-.+/.test(arg) && get(flags.negatable, arg.replace(/^--no-/, "")) ) { const m = arg.match(/^--no-(.+)/); assert(m != null); setArg(m[1], false, arg, false); } else if (/^--.+/.test(arg)) { const m = arg.match(/^--(.+)/); assert(m != null); const [, key] = m; const next = args[i + 1]; if ( next !== undefined && !/^-/.test(next) && !get(flags.bools, key) && !flags.allBools && (get(aliases, key) ? !aliasIsBoolean(key) : true) ) { setArg(key, next, arg); i++; } else if (/^(true|false)$/.test(next)) { setArg(key, next === "true", arg); i++; } else { setArg(key, get(flags.strings, key) ? "" : true, arg); } } else if (/^-[^-]+/.test(arg)) { const letters = arg.slice(1, -1).split("");
let broken = false; for (let j = 0; j < letters.length; j++) { const next = arg.slice(j + 2);
if (next === "-") { setArg(letters[j], next, arg); continue; }
if (/[A-Za-z]/.test(letters[j]) && /=/.test(next)) { setArg(letters[j], next.split(/=(.+)/)[1], arg); broken = true; break; }
if ( /[A-Za-z]/.test(letters[j]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next) ) { setArg(letters[j], next, arg); broken = true; break; }
if (letters[j + 1] && letters[j + 1].match(/\W/)) { setArg(letters[j], arg.slice(j + 2), arg); broken = true; break; } else { setArg(letters[j], get(flags.strings, letters[j]) ? "" : true, arg); } }
const [key] = arg.slice(-1); if (!broken && key !== "-") { if ( args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !get(flags.bools, key) && (get(aliases, key) ? !aliasIsBoolean(key) : true) ) { setArg(key, args[i + 1], arg); i++; } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) { setArg(key, args[i + 1] === "true", arg); i++; } else { setArg(key, get(flags.strings, key) ? "" : true, arg); } } } else { if (!flags.unknownFn || flags.unknownFn(arg) !== false) { argv._.push(flags.strings["_"] ?? !isNumber(arg) ? arg : Number(arg)); } if (stopEarly) { argv._.push(...args.slice(i + 1)); break; } } }
for (const [key, value] of Object.entries(defaults)) { if (!hasKey(argv, key.split("."))) { setKey(argv, key, value);
if (aliases[key]) { for (const x of aliases[key]) { setKey(argv, x, value); } } } }
for (const key of Object.keys(flags.bools)) { if (!hasKey(argv, key.split("."))) { const value = get(flags.collect, key) ? [] : false; setKey( argv, key, value, false, ); } }
for (const key of Object.keys(flags.strings)) { if (!hasKey(argv, key.split(".")) && get(flags.collect, key)) { setKey( argv, key, [], false, ); } }
if (doubleDash) { argv["--"] = []; for (const key of notFlags) { argv["--"].push(key); } } else { for (const key of notFlags) { argv._.push(key); } }
return argv as Args<V, DD>;}