Add zod validation library

src/Logger.ts

@@ -1,20 +1,8 @@
-import { LogLabel, LogLevel } from "./types/logger";
+import { LogLabel, LogLevel, LogOutputs } from "./types/logger";
 import { gzip, randomString, stringifyInstance, ungzip } from "./lib/utilities";
-import {
-  DEFAULT_OUTPUTS,
-  DEFAULT_CONFIG,
-  DEFAULT_STYLES,
-} from "./lib/defaults";
+import { DEFAULT_STYLES } from "./lib/defaults";
 
-import type {
-  LogOutputs,
-  LogContext,
-  BucketInfo,
-  LogMeta,
-  LogConfig,
-} from "./types/logger";
-
-import type { DeepRequired } from "generic";
+import { LogContext, BucketInfo, LogMeta, LogConfig } from "./types/logger";
 
 const MESSAGE_STYLE = "background: inherit; color: inherit;";
 
@@ -36,44 +24,15 @@ export class Logger {
   private buffer: string[];
   private bufferLength: number;
   private bucketIndex: BucketInfo[];
-  private outputs: DeepRequired<LogOutputs>;
+  private outputs: LogOutputs;
   private bufferCapacity: number;
 
-  constructor(config: LogConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG))) {
+  constructor(config: Partial<LogConfig> = {}) {
     this.buffer = [];
     this.bufferLength = 0;
-    this.bufferCapacity = config.bufferCapacity
-      ? config.bufferCapacity
-      : DEFAULT_CONFIG.bufferCapacity;
-
-    // Parse outputs config
-    if (!config.outputs) {
-      this.outputs = JSON.parse(JSON.stringify(DEFAULT_OUTPUTS));
-    } else {
-      this.outputs = {
-        console: {
-          enabled: config.outputs.console
-            ? config.outputs.console.enabled
-            : DEFAULT_OUTPUTS.console.enabled,
-        },
-        tampermonkey: {
-          enabled: config.outputs.tampermonkey
-            ? config.outputs.tampermonkey.enabled
-            : DEFAULT_OUTPUTS.tampermonkey.enabled,
-          bucketIndexKey:
-            config.outputs.tampermonkey &&
-            config.outputs.tampermonkey.bucketIndexKey
-              ? config.outputs.tampermonkey.bucketIndexKey
-              : DEFAULT_OUTPUTS.tampermonkey.bucketIndexKey,
-          maxBuckets:
-            config.outputs.tampermonkey &&
-            config.outputs.tampermonkey.maxBuckets
-              ? config.outputs.tampermonkey.maxBuckets
-              : DEFAULT_OUTPUTS.tampermonkey.maxBuckets,
-        },
-        callback: config.outputs.callback ? config.outputs.callback : undefined,
-      };
-    }
+    const parsedConfig = LogConfig.parse(config);
+    this.bufferCapacity = parsedConfig.bufferCapacity;
+    this.outputs = parsedConfig.outputs;
 
     if (this.outputs.tampermonkey.enabled) {
       this.bucketIndex = JSON.parse(

src/lib/defaults.ts

@@ -1,20 +1,5 @@
 import type { DeepRequired } from "../types/generic";
-import type { ConsoleStyles, LogConfig, LogOutputs } from "../types/logger";
-
-export const DEFAULT_OUTPUTS: DeepRequired<LogOutputs> = {
-  console: { enabled: true },
-  tampermonkey: {
-    enabled: false,
-    maxBuckets: 10,
-    bucketIndexKey: "bucket_index",
-  },
-  callback: undefined,
-};
-
-export const DEFAULT_CONFIG: DeepRequired<LogConfig> = {
-  outputs: DEFAULT_OUTPUTS,
-  bufferCapacity: 100000,
-};
+import type { ConsoleStyles } from "../types/logger";
 
 export const DEFAULT_STYLES: DeepRequired<ConsoleStyles> = {
   trace: {

src/types/logger.ts

@@ -1,3 +1,5 @@
+import { z } from "zod";
+
 export enum LogLevel {
   TRACE = 10,
   DEBUG = 20,
@@ -24,16 +26,30 @@ export interface ConsoleOutputOpts {
   enabled: boolean;
 }
 
-export interface LogOutputs {
-  console?: ConsoleOutputOpts;
-  tampermonkey?: TampermonkeyOutputOpts;
-  callback: ((message: string) => any) | undefined;
-}
+export const LogOutputs = z.object({
+  console: z
+    .object({
+      enabled: z.boolean().default(true),
+    })
+    .default({}),
+  tampermonkey: z
+    .object({
+      enabled: z.boolean().default(false),
+      maxBuckets: z.number().default(10),
+      bucketIndexKey: z.string().default("bucket_index"),
+    })
+    .default({}),
+  callback: z.function().args(z.string()).nullish(),
+});
 
-export interface LogConfig {
-  outputs?: LogOutputs;
-  bufferCapacity?: number;
-}
+export type LogOutputs = z.infer<typeof LogOutputs>;
+
+export const LogConfig = z.object({
+  outputs: LogOutputs.default({}),
+  bufferCapacity: z.number().default(100000),
+});
+
+export type LogConfig = z.infer<typeof LogConfig>;
 
 export interface LogContext {
   level?: number;