moar

1 files changed, 40 insertions, 27 deletions

diff --git a/u/trace/logger.ts b/u/trace/logger.ts
index 79da367..4f3c856 100644
--- a/u/trace/logger.ts
+++ b/u/trace/logger.ts
@@ -1,10 +1,9 @@
 import {
   isDebug,
-  isObject,
   type ITrace,
   type SideEffect,
   type Supplier,
-} from "@emprespresso/utils";
+} from "@emprespresso/pengueno";
 
 export interface ILogger {
   log: (...args: unknown[]) => void;
@@ -12,74 +11,88 @@ export interface ILogger {
   warn: (...args: unknown[]) => void;
   error: (...args: unknown[]) => void;
 }
-export type ILoggerLevel = "UNKNOWN" | "INFO" | "WARN" | "DEBUG" | "ERROR";
-const logLevelOrder: Array<ILoggerLevel> = ["DEBUG", "INFO", "WARN", "ERROR"];
+export enum LogLevel {
+  UNKNOWN = "UNKNOWN",
+  INFO = "INFO",
+  WARN = "WARN",
+  DEBUG = "DEBUG",
+  ERROR = "ERROR",
+}
+const logLevelOrder: Array<LogLevel> = [
+  LogLevel.DEBUG,
+  LogLevel.INFO,
+  LogLevel.WARN,
+  LogLevel.ERROR,
+];
+export const isLogLevel = (l: string): l is LogLevel =>
+  logLevelOrder.some((level) => <string> level === l);
+
 const defaultAllowedLevels = () =>
   [
-    "UNKNOWN",
-    ...(isDebug() ? ["DEBUG"] : []),
-    "INFO",
-    "WARN",
-    "ERROR",
-  ] as Array<ILoggerLevel>;
+    LogLevel.UNKNOWN,
+    ...(isDebug() ? [LogLevel.DEBUG] : []),
+    LogLevel.INFO,
+    LogLevel.WARN,
+    LogLevel.ERROR,
+  ] as Array<LogLevel>;
 
 export const logWithLevel = (
   logger: ILogger,
-  level: ILoggerLevel,
+  level: LogLevel,
 ): SideEffect<unknown> => {
   switch (level) {
-    case "UNKNOWN":
-    case "INFO":
+    case LogLevel.UNKNOWN:
+    case LogLevel.INFO:
       return logger.log;
-    case "DEBUG":
+    case LogLevel.DEBUG:
       return logger.debug;
-    case "WARN":
+    case LogLevel.WARN:
       return logger.warn;
-    case "ERROR":
+    case LogLevel.ERROR:
       return logger.error;
   }
 };
 
 export const LoggerImpl = console;
 
-export type LogTraceSupplier = string | Supplier<string> | {
-  level: ILoggerLevel;
-};
+export type LogTraceSupplier = string | Supplier<string>;
 
 const foldTraces = (traces: Array<LogTraceSupplier>) => {
   const { line, level } = traces.reduce(
     (acc: { line: string; level: number }, t) => {
-      if (isObject(t) && "level" in t) {
+      const val = typeof t === "function" ? t() : t;
+      if (isLogLevel(val)) {
         return {
           ...acc,
-          level: Math.max(logLevelOrder.indexOf(t.level), acc.level),
+          level: Math.max(logLevelOrder.indexOf(val), acc.level),
         };
       }
       const prefix = [
         acc.line,
-        typeof t === "function" ? t() : t,
+        val,
       ].join(" ");
       return { ...acc, prefix };
     },
     { line: "", level: -1 },
   );
-  return { line, level: logLevelOrder[level] ?? "UNKNOWN" };
+  return { line, level: logLevelOrder[level] ?? LogLevel.UNKNOWN };
 };
 
 const defaultTrace = () => `[${new Date().toISOString()}]`;
 export const LogTrace = (
   logger: ILogger,
   traces: Array<LogTraceSupplier> = [defaultTrace],
-  allowedLevels: Supplier<Array<ILoggerLevel>> = defaultAllowedLevels,
-  defaultLevel: ILoggerLevel = "INFO",
+  allowedLevels: Supplier<Array<LogLevel>> = defaultAllowedLevels,
+  defaultLevel: LogLevel = LogLevel.INFO,
 ): ITrace<LogTraceSupplier> => {
   return {
     addTrace: (trace: LogTraceSupplier) =>
-      LogTrace(logger, traces.concat(trace)),
+      LogTrace(logger, traces.concat(trace), allowedLevels, defaultLevel),
     trace: (trace: LogTraceSupplier) => {
       const { line, level: _level } = foldTraces(traces.concat(trace));
       if (!allowedLevels().includes(_level)) return;
-      const level = _level === "UNKNOWN" ? defaultLevel : _level;
+
+      const level = _level === LogLevel.UNKNOWN ? defaultLevel : _level;
       logWithLevel(logger, level)(`[${level}]${line}`);
     },
   };