From 55519c21af02b344fa9753111e3bf6f4975b0479 Mon Sep 17 00:00:00 2001
From: Elizabeth Hunt <me@liz.coffee>
Date: Sat, 14 Jun 2025 12:27:04 -0700
Subject: Fix some logging stuff

---
 u/process/argv.ts | 118 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 62 insertions(+), 56 deletions(-)

(limited to 'u/process/argv.ts')

diff --git a/u/process/argv.ts b/u/process/argv.ts
index 8e85477..45f8ff0 100644
--- a/u/process/argv.ts
+++ b/u/process/argv.ts
@@ -1,66 +1,72 @@
-import { Either, type IEither } from "@emprespresso/pengueno";
+import { Either, type Mapper, type IEither } from "@emprespresso/pengueno";
 
 export const isArgKey = <K extends string>(k: string): k is K =>
   k.startsWith("--");
 
-export const getArg = <K extends string, V extends string>(
+interface ArgHandler<V> {
+    absent?: V;
+    unspecified?: V;
+    present: Mapper<string, V>;
+}
+
+export const getArg = <K extends string, V>(
   arg: K,
-  args: Array<K>,
+  argv: Array<string>,
+  whenValue: ArgHandler<V>,
 ): IEither<Error, V> => {
-  const result = args.findIndex((_arg) => _arg.startsWith(arg));
-  if (result < 0) return Either.left(new Error("no argument found for " + arg));
-  const [resultArg, next]: Array<string | undefined> = [
-    args[result],
-    args.at(result + 1),
-  ];
-  if (resultArg && resultArg.includes("=")) {
-    return Either.right(resultArg.split("=")[1] as V);
-  }
-  if (typeof next === "undefined")
-    return Either.left(new Error("no value specified for " + arg));
-  if (isArgKey(next))
-    return Either.left(
-      new Error("next value for arg " + arg + " is another arg " + next),
-    );
-  return Either.right(next as V);
+    const value = argv.filter((_argv) => isArgKey(_argv) && _argv.split("=")[0] === arg).map((_argv, i) => {
+        const next = _argv.includes("=") ? _argv.split("=")[1] : argv.at(i + 1);
+        if (next) {
+            if (isArgKey(next)) return whenValue.unspecified;
+            return whenValue.present(next);
+        }
+        return whenValue.unspecified;
+    }).find(x => x) ?? whenValue.absent;
+    if (value === undefined) {
+        return Either.left(new Error("no value specified for " + arg));
+    }
+    return Either.right(value);
 };
 
-type ObjectFromList<T extends ReadonlyArray<string>, V = string> = {
-  [K in T extends ReadonlyArray<infer U> ? U : never]: V;
+type MappedArgs<
+  Args extends ReadonlyArray<string>,
+  Handlers extends Partial<Record<Args[number], ArgHandler<unknown>>>
+> = {
+  [K in Args[number]]: K extends keyof Handlers
+    ? Handlers[K] extends ArgHandler<infer T>
+      ? T
+      : string
+    : string;
 };
-export const argv = <K extends string, V extends string>(
-  args: ReadonlyArray<K>,
-  defaultArgs?: Partial<Record<K, V>>,
-  argv = Deno.args,
-) => {
-  return args
-    .map((arg) => [arg, getArg(arg, argv)] as [K, IEither<Error, V>])
-    .map(([arg, specified]): [K, IEither<Error, V>] => [
-      arg,
-      specified.fold(({ isLeft, isRight, value }): IEither<Error, V> => {
-        if (isRight) {
-          return Either.right(value);
-        }
-        const hasDefaultVal = isLeft && defaultArgs && arg in defaultArgs;
-        if (hasDefaultVal) {
-          return Either.right(defaultArgs[arg]!);
-        }
-        return Either.left(value);
-      }),
-    ])
-    .reduce(
-      (
-        acc: IEither<Error, ObjectFromList<typeof args, V>>,
-        x: [K, IEither<Error, V>],
-      ): IEither<Error, ObjectFromList<typeof args, V>> => {
-        const [arg, eitherVal] = x;
-        return acc.flatMap((args) => {
-          return eitherVal.mapRight((envValue) => ({
-            ...args,
-            [arg]: envValue,
-          }));
-        });
-      },
-      Either.right({} as ObjectFromList<typeof args, V>),
-    );
+
+export const argv = <
+  const Args extends ReadonlyArray<string>,
+  const Handlers extends Partial<Record<Args[number], ArgHandler<unknown>>>
+>(
+    args: Args,
+    handlers?: Handlers,
+    argv = Deno.args,
+): IEither<Error, MappedArgs<Args, Handlers>> => {
+    type Result = MappedArgs<Args, Handlers>;
+
+    const defaultHandler: ArgHandler<string> = { present: (value: string) => value };
+
+    const processArg = (arg: Args[number]): IEither<Error, [Args[number], unknown]> => {
+        const handler = handlers?.[arg] ?? defaultHandler;
+        return getArg(arg, argv, handler).mapRight(value => [arg, value] as const);
+    };
+
+    const argResults = args.map(processArg);
+
+    return argResults.reduce(
+        (acc: IEither<Error, Partial<Result>>, current: IEither<Error, readonly [Args[number], unknown]>) => {
+            return acc.flatMap(accValue =>
+                current.mapRight(([key, value]) => ({
+                    ...accValue,
+                    [key]: value
+                }))
+            );
+        },
+        Either.right({} as Partial<Result>)
+    ).mapRight(result => result as Result);
 };
-- 
cgit v1.2.3-70-g09d2