import { assert } from "../assert/assert.ts";
type Id<TRecord> = TRecord extends Record<string, unknown> ? TRecord extends infer InferredRecord ? { [Key in keyof InferredRecord]: Id<InferredRecord[Key]> } : never : TRecord;
type UnionToIntersection<TValue> = (TValue extends unknown ? (args: TValue) => 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< TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable,> = undefined extends ( & (false extends TBooleans ? undefined : TBooleans) & TCollectable & TStrings) ? false : true;
type Values< TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable, TNegatable extends Negatable, TDefault extends Record<string, unknown> | undefined, TAliases extends Aliases | undefined,> = UseTypes<TBooleans, TStrings, TCollectable> extends true ? & Record<string, unknown> & AddAliases< SpreadDefaults< & CollectValues<TStrings, string, TCollectable, TNegatable> & RecursiveRequired<CollectValues<TBooleans, boolean, TCollectable>> & CollectUnknownValues< TBooleans, TStrings, TCollectable, TNegatable >, DedotRecord<TDefault> >, TAliases > : Record<string, any>;
type Aliases<TArgNames = string, TAliasNames extends string = string> = Partial< Record<Extract<TArgNames, string>, TAliasNames | ReadonlyArray<TAliasNames>>>;
type AddAliases< TArgs, TAliases extends Aliases | undefined,> = { [TArgName in keyof TArgs as AliasNames<TArgName, TAliases>]: TArgs[TArgName];};
type AliasNames< TArgName, TAliases extends Aliases | undefined,> = TArgName extends keyof TAliases ? string extends TAliases[TArgName] ? TArgName : TAliases[TArgName] extends string ? TArgName | TAliases[TArgName] : TAliases[TArgName] extends Array<string> ? TArgName | TAliases[TArgName][number] : TArgName : TArgName;
type SpreadDefaults<TArgs, TDefaults> = TDefaults extends undefined ? TArgs : TArgs extends Record<string, unknown> ? & Omit<TArgs, keyof TDefaults> & { [Default in keyof TDefaults]: Default extends keyof TArgs ? (TArgs[Default] & TDefaults[Default] | TDefaults[Default]) extends Record<string, unknown> ? NonNullable<SpreadDefaults<TArgs[Default], TDefaults[Default]>> : TDefaults[Default] | NonNullable<TArgs[Default]> : unknown; } : never;
type Defaults<TBooleans extends BooleanType, TStrings extends StringType> = Id< UnionToIntersection< & Record<string, unknown> & MapTypes<TStrings, unknown> & MapTypes<TBooleans, unknown> & MapDefaults<TBooleans> & MapDefaults<TStrings> >>;
type MapDefaults<TArgNames extends ArgType> = Partial< Record<TArgNames extends string ? TArgNames : string, unknown>>;
type RecursiveRequired<TRecord> = TRecord extends Record<string, unknown> ? { [Key in keyof TRecord]-?: RecursiveRequired<TRecord[Key]>; } : TRecord;
type CollectValues< TArgNames extends ArgType, TType, TCollectable extends Collectable, TNegatable extends Negatable = undefined,> = UnionToIntersection< Extract<TArgNames, TCollectable> extends string ? & (Exclude<TArgNames, TCollectable> extends never ? Record<never, never> : MapTypes<Exclude<TArgNames, TCollectable>, TType, TNegatable>) & (Extract<TArgNames, TCollectable> extends never ? Record<never, never> : RecursiveRequired< MapTypes<Extract<TArgNames, TCollectable>, Array<TType>, TNegatable> >) : MapTypes<TArgNames, TType, TNegatable>>;
type MapTypes< TArgNames extends ArgType, TType, TNegatable extends Negatable = undefined,> = undefined extends TArgNames ? Record<never, never> : TArgNames extends `${infer Name}.${infer Rest}` ? { [Key in Name]?: MapTypes< Rest, TType, TNegatable extends `${Name}.${infer Negate}` ? Negate : undefined >; } : TArgNames extends string ? Partial< Record<TArgNames, TNegatable extends TArgNames ? TType | false : TType> > : Record<never, never>;
type CollectUnknownValues< TBooleans extends BooleanType, TStrings extends StringType, TCollectable extends Collectable, TNegatable extends Negatable,> = UnionToIntersection< TCollectable extends TBooleans & TStrings ? Record<never, never> : DedotRecord< & Record< Exclude< Extract<Exclude<TCollectable, TNegatable>, string>, Extract<TStrings | TBooleans, string> >, Array<unknown> > & Record< Exclude< Extract<Extract<TCollectable, TNegatable>, string>, Extract<TStrings | TBooleans, string> >, Array<unknown> | false > >>;
type DedotRecord<TRecord> = Record<string, unknown> extends TRecord ? TRecord : TRecord extends Record<string, unknown> ? UnionToIntersection< ValueOf< { [Key in keyof TRecord]: Key extends string ? Dedot<Key, TRecord[Key]> : never; } > > : TRecord;
type Dedot<TKey extends string, TValue> = TKey extends `${infer Name}.${infer Rest}` ? { [Key in Name]: Dedot<Rest, TValue> } : { [Key in TKey]: TValue };
type ValueOf<TValue> = TValue[keyof TValue];
export type Args< TArgs extends Record<string, unknown> = Record<string, any>, TDoubleDash extends boolean | undefined = undefined,> = Id< & TArgs & { _: Array<string | number>; } & (boolean extends TDoubleDash ? DoubleDash : true extends TDoubleDash ? Required<DoubleDash> : Record<never, never>)>;
type DoubleDash = { "--"?: Array<string>;};
export interface ParseOptions< TBooleans extends BooleanType = BooleanType, TStrings extends StringType = StringType, TCollectable extends Collectable = Collectable, TNegatable extends Negatable = Negatable, TDefault extends Record<string, unknown> | undefined = | Record<string, unknown> | undefined, TAliases extends Aliases | undefined = Aliases | undefined, TDoubleDash extends boolean | undefined = boolean | undefined,> { "--"?: TDoubleDash;
alias?: TAliases;
boolean?: TBooleans | ReadonlyArray<Extract<TBooleans, string>>;
default?: TDefault & Defaults<TBooleans, TStrings>;
stopEarly?: boolean;
string?: TStrings | ReadonlyArray<Extract<TStrings, string>>;
collect?: TCollectable | ReadonlyArray<Extract<TCollectable, string>>;
negatable?: TNegatable | ReadonlyArray<Extract<TNegatable, string>>;
unknown?: (arg: string, key?: string, value?: unknown) => unknown;}
interface NestedMapping { [key: string]: NestedMapping | unknown;}
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 setNested( object: NestedMapping, keys: string[], value: unknown, collect = false,) { keys.slice(0, -1).forEach((key) => { object[key] ??= {}; object = object[key] as NestedMapping; });
const key = keys.at(-1)!;
if (collect) { const v = object[key]; if (Array.isArray(v)) { v.push(value); return; }
value = v ? [v, value] : [value]; }
object[key] = value;}
function hasNested(object: NestedMapping, keys: string[]): boolean { keys = [...keys]; const lastKey = keys.pop(); if (!lastKey) return false; for (const key of keys) { if (!object[key]) return false; object = object[key] as NestedMapping; } return Object.hasOwn(object, lastKey);}
function aliasIsBoolean( aliasMap: Map<string, Set<string>>, booleanSet: Set<string>, key: string,): boolean { const set = aliasMap.get(key); if (set === undefined) return false; for (const alias of set) if (booleanSet.has(alias)) return true; return false;}
function isBooleanString(value: string) { return value === "true" || value === "false";}
function parseBooleanString(value: unknown) { return value !== "false";}
const FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
export function parseArgs< TArgs extends Values< TBooleans, TStrings, TCollectable, TNegatable, TDefaults, TAliases >, TDoubleDash extends boolean | undefined = undefined, TBooleans extends BooleanType = undefined, TStrings extends StringType = undefined, TCollectable extends Collectable = undefined, TNegatable extends Negatable = undefined, TDefaults extends Record<string, unknown> | undefined = undefined, TAliases extends Aliases<TAliasArgNames, TAliasNames> | undefined = undefined, TAliasArgNames extends string = string, TAliasNames extends string = string,>( args: string[], { "--": doubleDash = false, alias = {} as NonNullable<TAliases>, boolean = false, default: defaults = {} as TDefaults & Defaults<TBooleans, TStrings>, stopEarly = false, string = [], collect = [], negatable = [], unknown: unknownFn = (i: string): unknown => i, }: ParseOptions< TBooleans, TStrings, TCollectable, TNegatable, TDefaults, TAliases, TDoubleDash > = {},): Args<TArgs, TDoubleDash> { const aliasMap: Map<string, Set<string>> = new Map(); const booleanSet = new Set<string>(); const stringSet = new Set<string>(); const collectSet = new Set<string>(); const negatableSet = new Set<string>();
let allBools = false;
if (alias) { for (const key in alias) { const val = (alias as Record<string, unknown>)[key]; assert(val !== undefined); const aliases = Array.isArray(val) ? val : [val]; aliasMap.set(key, new Set(aliases)); aliases.forEach((alias) => aliasMap.set( alias, new Set([key, ...aliases.filter((it) => it !== alias)]), ) ); } }
if (boolean) { if (typeof boolean === "boolean") { allBools = boolean; } else { const booleanArgs = Array.isArray(boolean) ? boolean : [boolean]; for (const key of booleanArgs.filter(Boolean)) { booleanSet.add(key); aliasMap.get(key)?.forEach((al) => { booleanSet.add(al); }); } } }
if (string) { const stringArgs = Array.isArray(string) ? string : [string]; for (const key of stringArgs.filter(Boolean)) { stringSet.add(key); aliasMap.get(key)?.forEach((al) => stringSet.add(al)); } }
if (collect) { const collectArgs = Array.isArray(collect) ? collect : [collect]; for (const key of collectArgs.filter(Boolean)) { collectSet.add(key); aliasMap.get(key)?.forEach((al) => collectSet.add(al)); } }
if (negatable) { const negatableArgs = Array.isArray(negatable) ? negatable : [negatable]; for (const key of negatableArgs.filter(Boolean)) { negatableSet.add(key); aliasMap.get(key)?.forEach((alias) => negatableSet.add(alias)); } }
const argv: Args = { _: [] };
function setArgument( key: string, value: string | number | boolean, arg: string, collect: boolean, ) { if ( !booleanSet.has(key) && !stringSet.has(key) && !aliasMap.has(key) && !(allBools && /^--[^=]+$/.test(arg)) && unknownFn?.(arg, key, value) === false ) { return; } if (typeof value === "string" && !stringSet.has(key)) { value = isNumber(value) ? Number(value) : value; }
const collectable = collect && collectSet.has(key); setNested(argv, key.split("."), value, collectable); aliasMap.get(key)?.forEach((key) => { setNested(argv, key.split("."), value, collectable); }); }
let notFlags: string[] = [];
const index = args.indexOf("--"); if (index !== -1) { notFlags = args.slice(index + 1); args = args.slice(0, index); }
for (let i = 0; i < args.length; i++) { const arg = args[i]!;
const groups = arg.match(FLAG_REGEXP)?.groups;
if (groups) { const { doubleDash, negated } = groups; let key = groups.key!; let value: string | number | boolean | undefined = groups.value;
if (doubleDash) { if (value) { if (booleanSet.has(key)) value = parseBooleanString(value); setArgument(key, value, arg, true); continue; }
if (negated) { if (negatableSet.has(key)) { setArgument(key, false, arg, false); continue; } key = `no-${key}`; }
const next = args[i + 1];
if ( !booleanSet.has(key) && !allBools && next && !/^-/.test(next) && (aliasMap.get(key) ? !aliasIsBoolean(aliasMap, booleanSet, key) : true) ) { value = next; i++; setArgument(key, value, arg, true); continue; }
if (next && isBooleanString(next)) { value = parseBooleanString(next); i++; setArgument(key, value, arg, true); continue; }
value = stringSet.has(key) ? "" : true; setArgument(key, value, arg, true); continue; } const letters = arg.slice(1, -1).split("");
let broken = false; for (const [j, letter] of letters.entries()) { const next = arg.slice(j + 2);
if (next === "-") { setArgument(letter, next, arg, true); continue; }
if (/[A-Za-z]/.test(letter) && /=/.test(next)) { setArgument(letter, next.split(/=(.+)/)[1]!, arg, true); broken = true; break; }
if ( /[A-Za-z]/.test(letter) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next) ) { setArgument(letter, next, arg, true); broken = true; break; }
if (letters[j + 1] && letters[j + 1]!.match(/\W/)) { setArgument(letter, arg.slice(j + 2), arg, true); broken = true; break; } setArgument( letter, stringSet.has(letter) ? "" : true, arg, true, ); }
key = arg.slice(-1); if (!broken && key !== "-") { const nextArg = args[i + 1]; if ( nextArg && !/^(-|--)[^-]/.test(nextArg) && !booleanSet.has(key) && (aliasMap.get(key) ? !aliasIsBoolean(aliasMap, booleanSet, key) : true) ) { setArgument(key, nextArg, arg, true); i++; } else if (nextArg && isBooleanString(nextArg)) { const value = parseBooleanString(nextArg); setArgument(key, value, arg, true); i++; } else { setArgument(key, stringSet.has(key) ? "" : true, arg, true); } } continue; }
if (unknownFn?.(arg) !== false) { argv._.push( stringSet.has("_") || !isNumber(arg) ? arg : Number(arg), ); }
if (stopEarly) { argv._.push(...args.slice(i + 1)); break; } }
for (const [key, value] of Object.entries(defaults)) { const keys = key.split("."); if (!hasNested(argv, keys)) { setNested(argv, keys, value); aliasMap.get(key)?.forEach((key) => setNested(argv, key.split("."), value) ); } }
for (const key of booleanSet.keys()) { const keys = key.split("."); if (!hasNested(argv, keys)) { const value = collectSet.has(key) ? [] : false; setNested(argv, keys, value); } }
for (const key of stringSet.keys()) { const keys = key.split("."); if (!hasNested(argv, keys) && collectSet.has(key)) { setNested(argv, keys, []); } }
if (doubleDash) { argv["--"] = []; for (const key of notFlags) { argv["--"].push(key); } } else { for (const key of notFlags) { argv._.push(key); } }
return argv as Args<TArgs, TDoubleDash>;}