@tkeron/tools 0.3.0 → 0.4.0

package/changelog.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.4.0] - 2026-02-15
+
+### Added
+
+- **Logger system**: Generic logging abstraction for standardized logging across the ecosystem
+  - `Logger` interface: Standard interface with `log`, `error`, `warn`, `info` methods
+  - `logger`: Default implementation using console methods
+  - `silentLogger`: No-op logger for silent operation (useful in production or tests)
+  - `createTestLogger()`: Captures logs in arrays for testing and verification
+  - Full TypeScript support with exported types
+  - Comprehensive test coverage (45 tests across 3 test files)
+
+### Documentation
+
+- Logger system fully tested with edge cases (null, undefined, Error objects, mixed types)
+- Test logger supports independent instances and manual array manipulation
+
 ## [0.3.0] - 2026-02-15
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tkeron/tools",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Useful JavaScript utilities for Bun runtime",
   "main": "src/index.ts",
   "module": "src/index.ts",

package/readme.md

@@ -27,9 +27,88 @@ import * as tools from "@tkeron/tools";
 import { rng, getLIFO, getPaths } from "@tkeron/tools";
 ```
 
+## 📚 Available Utilities
+
+### Logger System
+
+Generic logging abstraction for standardized logging across applications:
+
+```typescript
+import { Logger, logger, silentLogger, createTestLogger } from "@tkeron/tools";
+
+// Default logger (uses console)
+logger.log("Hello world");
+logger.error("Error message");
+logger.warn("Warning message");
+logger.info("Info message");
+
+// Silent logger (no output, useful for production or testing)
+silentLogger.log("This won't appear");
+
+// Test logger (captures logs in arrays for testing)
+const { logger: testLog, logs, errors, warns, infos } = createTestLogger();
+testLog.log("Test message");
+console.log(logs); // ["Test message"]
+
+// Inject logger in your functions
+const myFunction = (data: string, log: Logger = logger) => {
+  log.info("Processing:", data);
+  // ... your logic
+};
+```
+
+### File System Utilities
+
+Glob pattern matching and path retrieval:
+
+```typescript
+import { getPaths, getFilePaths, getDirectoryPaths } from "@tkeron/tools";
+
+// Get all files and directories
+const allPaths = getPaths("/path/to/dir", "**/*", "yes");
+
+// Get only files
+const files = getFilePaths("/path/to/dir", "**/*.ts");
+
+// Get only directories
+const dirs = getDirectoryPaths("/path/to/dir", "**/");
+```
+
+### Data Structures
+
+Stack implementations (LIFO/FIFO):
+
+```typescript
+import { getLIFO, getFIFO } from "@tkeron/tools";
+
+const stack = getLIFO<string>();
+stack.push("first");
+stack.push("second");
+console.log(stack.current); // "second"
+console.log(stack.pop()); // "second"
+```
+
+### Random Number Generator
+
+Seedable random number generator:
+
+```typescript
+import { rng } from "@tkeron/tools";
+
+// Generate infinite sequence with seed
+for (const num of rng(42)) {
+  console.log(num);
+}
+
+// Generate limited sequence
+for (const num of rng(42, 10)) {
+  console.log(num); // Only 10 numbers
+}
+```
+
 ## 📚 Documentation
 
-For detailed documentation of all available utilities, please refer to the TypeScript definitions or explore the source code. Each utility is fully typed and includes JSDoc comments for better IDE support.
+For detailed documentation and TypeScript definitions, refer to the source code. Each utility is fully typed with JSDoc comments for IDE support.
 
 ## 🧪 Testing
 

package/src/createTestLogger.ts

@@ -0,0 +1,31 @@
+import type { Logger } from "./loggerObj.js";
+
+export const createTestLogger = () => {
+  const logs: string[] = [];
+  const errors: string[] = [];
+  const warns: string[] = [];
+  const infos: string[] = [];
+
+  const format = (args: unknown[]) =>
+    args
+      .map((a) => {
+        if (typeof a === "string") return a;
+        if (a === undefined) return "undefined";
+        if (a instanceof Error) return a.stack || a.message || String(a);
+        return JSON.stringify(a);
+      })
+      .join(" ");
+
+  return {
+    logger: {
+      log: (...args: unknown[]) => logs.push(format(args)),
+      error: (...args: unknown[]) => errors.push(format(args)),
+      warn: (...args: unknown[]) => warns.push(format(args)),
+      info: (...args: unknown[]) => infos.push(format(args)),
+    } as Logger,
+    logs,
+    errors,
+    warns,
+    infos,
+  };
+};

package/src/index.ts

@@ -1,3 +1,6 @@
 export * from "./random";
 export * from "./stack";
 export * from "./getPaths";
+export * from "./loggerObj";
+export * from "./silentLogger";
+export * from "./createTestLogger";

package/src/loggerObj.ts

@@ -0,0 +1,13 @@
+export interface Logger {
+  log: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+}
+
+export const logger: Logger = {
+  log: (...args: unknown[]) => console.log(...args),
+  error: (...args: unknown[]) => console.error(...args),
+  warn: (...args: unknown[]) => console.warn(...args),
+  info: (...args: unknown[]) => console.info(...args),
+};

package/src/silentLogger.ts

@@ -0,0 +1,8 @@
+import type { Logger } from "./loggerObj.js";
+
+export const silentLogger: Logger = {
+  log: () => {},
+  error: () => {},
+  warn: () => {},
+  info: () => {},
+};

package/tests/createTestLogger.test.ts

@@ -0,0 +1,392 @@
+import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { createTestLogger } from "../src/createTestLogger.js";
+import type { Logger } from "../src/loggerObj.js";
+
+describe("createTestLogger", () => {
+  it("should return an object with logger and arrays", () => {
+    const result = createTestLogger();
+    expect(result).toHaveProperty("logger");
+    expect(result).toHaveProperty("logs");
+    expect(result).toHaveProperty("errors");
+    expect(result).toHaveProperty("warns");
+    expect(result).toHaveProperty("infos");
+    expect(Array.isArray(result.logs)).toBe(true);
+    expect(Array.isArray(result.errors)).toBe(true);
+    expect(Array.isArray(result.warns)).toBe(true);
+    expect(Array.isArray(result.infos)).toBe(true);
+  });
+
+  it("should return empty arrays initially", () => {
+    const { logs, errors, warns, infos } = createTestLogger();
+    expect(logs).toEqual([]);
+    expect(errors).toEqual([]);
+    expect(warns).toEqual([]);
+    expect(infos).toEqual([]);
+  });
+
+  it("should return a logger compatible with Logger interface", () => {
+    const { logger } = createTestLogger();
+    const testLogger: Logger = logger;
+    expect(testLogger).toBeDefined();
+  });
+
+  it("should have all required methods", () => {
+    const { logger } = createTestLogger();
+    expect(logger).toHaveProperty("log");
+    expect(logger).toHaveProperty("error");
+    expect(logger).toHaveProperty("warn");
+    expect(logger).toHaveProperty("info");
+    expect(typeof logger.log).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.info).toBe("function");
+  });
+});
+
+describe("createTestLogger.logger.log", () => {
+  let consoleSpy: any;
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, "log");
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it("should not call console.log", () => {
+    const { logger } = createTestLogger();
+    logger.log("test");
+    expect(consoleSpy).not.toHaveBeenCalled();
+  });
+
+  it("should capture single string", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log("test message");
+    expect(logs).toEqual(["test message"]);
+  });
+
+  it("should capture multiple strings", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log("test", "multiple", "args");
+    expect(logs).toEqual(["test multiple args"]);
+  });
+
+  it("should capture number", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(42);
+    expect(logs).toEqual(["42"]);
+  });
+
+  it("should capture object as JSON", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log({ key: "value" });
+    expect(logs).toEqual(['{"key":"value"}']);
+  });
+
+  it("should capture array as JSON", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log([1, 2, 3]);
+    expect(logs).toEqual(["[1,2,3]"]);
+  });
+
+  it("should capture null", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(null);
+    expect(logs).toEqual(["null"]);
+  });
+
+  it("should capture undefined", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(undefined);
+    expect(logs).toEqual(["undefined"]);
+  });
+
+  it("should capture boolean", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(true);
+    expect(logs).toEqual(["true"]);
+  });
+
+  it("should capture multiple calls", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log("first");
+    logger.log("second");
+    logger.log("third");
+    expect(logs).toEqual(["first", "second", "third"]);
+  });
+
+  it("should capture mixed types", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log("string", 42, { key: "val" });
+    expect(logs).toEqual(['string 42 {"key":"val"}']);
+  });
+
+  it("should capture empty string", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log("");
+    expect(logs).toEqual([""]);
+  });
+
+  it("should capture zero", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(0);
+    expect(logs).toEqual(["0"]);
+  });
+
+  it("should capture negative number", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(-42);
+    expect(logs).toEqual(["-42"]);
+  });
+
+  it("should capture NaN", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(NaN);
+    expect(logs).toEqual(["null"]);
+  });
+
+  it("should capture Infinity", () => {
+    const { logger, logs } = createTestLogger();
+    logger.log(Infinity);
+    expect(logs).toEqual(["null"]);
+  });
+
+  it("should not mutate logs array reference", () => {
+    const testLogger = createTestLogger();
+    const originalLogsRef = testLogger.logs;
+    testLogger.logger.log("test");
+    expect(testLogger.logs).toBe(originalLogsRef);
+  });
+});
+
+describe("createTestLogger.logger.error", () => {
+  let consoleSpy: any;
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it("should not call console.error", () => {
+    const { logger } = createTestLogger();
+    logger.error("test");
+    expect(consoleSpy).not.toHaveBeenCalled();
+  });
+
+  it("should capture single string", () => {
+    const { logger, errors } = createTestLogger();
+    logger.error("error message");
+    expect(errors).toEqual(["error message"]);
+  });
+
+  it("should capture multiple strings", () => {
+    const { logger, errors } = createTestLogger();
+    logger.error("error", "multiple", "args");
+    expect(errors).toEqual(["error multiple args"]);
+  });
+
+  it("should capture Error object", () => {
+    const { logger, errors } = createTestLogger();
+    const error = new Error("test error");
+    logger.error(error);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain("test error");
+  });
+
+  it("should capture null", () => {
+    const { logger, errors } = createTestLogger();
+    logger.error(null);
+    expect(errors).toEqual(["null"]);
+  });
+
+  it("should capture undefined", () => {
+    const { logger, errors } = createTestLogger();
+    logger.error(undefined);
+    expect(errors).toEqual(["undefined"]);
+  });
+
+  it("should capture multiple calls", () => {
+    const { logger, errors } = createTestLogger();
+    logger.error("first");
+    logger.error("second");
+    logger.error("third");
+    expect(errors).toEqual(["first", "second", "third"]);
+  });
+});
+
+describe("createTestLogger.logger.warn", () => {
+  let consoleSpy: any;
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, "warn");
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it("should not call console.warn", () => {
+    const { logger } = createTestLogger();
+    logger.warn("test");
+    expect(consoleSpy).not.toHaveBeenCalled();
+  });
+
+  it("should capture single string", () => {
+    const { logger, warns } = createTestLogger();
+    logger.warn("warning message");
+    expect(warns).toEqual(["warning message"]);
+  });
+
+  it("should capture multiple strings", () => {
+    const { logger, warns } = createTestLogger();
+    logger.warn("warn", "multiple", "args");
+    expect(warns).toEqual(["warn multiple args"]);
+  });
+
+  it("should capture null", () => {
+    const { logger, warns } = createTestLogger();
+    logger.warn(null);
+    expect(warns).toEqual(["null"]);
+  });
+
+  it("should capture undefined", () => {
+    const { logger, warns } = createTestLogger();
+    logger.warn(undefined);
+    expect(warns).toEqual(["undefined"]);
+  });
+
+  it("should capture multiple calls", () => {
+    const { logger, warns } = createTestLogger();
+    logger.warn("first");
+    logger.warn("second");
+    logger.warn("third");
+    expect(warns).toEqual(["first", "second", "third"]);
+  });
+});
+
+describe("createTestLogger.logger.info", () => {
+  let consoleSpy: any;
+
+  beforeEach(() => {
+    consoleSpy = spyOn(console, "info");
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  it("should not call console.info", () => {
+    const { logger } = createTestLogger();
+    logger.info("test");
+    expect(consoleSpy).not.toHaveBeenCalled();
+  });
+
+  it("should capture single string", () => {
+    const { logger, infos } = createTestLogger();
+    logger.info("info message");
+    expect(infos).toEqual(["info message"]);
+  });
+
+  it("should capture multiple strings", () => {
+    const { logger, infos } = createTestLogger();
+    logger.info("info", "multiple", "args");
+    expect(infos).toEqual(["info multiple args"]);
+  });
+
+  it("should capture null", () => {
+    const { logger, infos } = createTestLogger();
+    logger.info(null);
+    expect(infos).toEqual(["null"]);
+  });
+
+  it("should capture undefined", () => {
+    const { logger, infos } = createTestLogger();
+    logger.info(undefined);
+    expect(infos).toEqual(["undefined"]);
+  });
+
+  it("should capture multiple calls", () => {
+    const { logger, infos } = createTestLogger();
+    logger.info("first");
+    logger.info("second");
+    logger.info("third");
+    expect(infos).toEqual(["first", "second", "third"]);
+  });
+});
+
+describe("createTestLogger isolation", () => {
+  it("should create independent loggers", () => {
+    const logger1 = createTestLogger();
+    const logger2 = createTestLogger();
+
+    logger1.logger.log("logger1");
+    logger2.logger.log("logger2");
+
+    expect(logger1.logs).toEqual(["logger1"]);
+    expect(logger2.logs).toEqual(["logger2"]);
+  });
+
+  it("should not share state between instances", () => {
+    const logger1 = createTestLogger();
+    const logger2 = createTestLogger();
+
+    logger1.logger.log("test1");
+    logger1.logger.error("error1");
+
+    expect(logger2.logs).toEqual([]);
+    expect(logger2.errors).toEqual([]);
+  });
+
+  it("should allow manual array manipulation", () => {
+    const testLogger = createTestLogger();
+    testLogger.logger.log("test");
+    expect(testLogger.logs).toEqual(["test"]);
+
+    testLogger.logs.length = 0;
+    expect(testLogger.logs).toEqual([]);
+  });
+});
+
+describe("createTestLogger all methods", () => {
+  it("should capture to correct arrays", () => {
+    const { logger, logs, errors, warns, infos } = createTestLogger();
+
+    logger.log("log message");
+    logger.error("error message");
+    logger.warn("warn message");
+    logger.info("info message");
+
+    expect(logs).toEqual(["log message"]);
+    expect(errors).toEqual(["error message"]);
+    expect(warns).toEqual(["warn message"]);
+    expect(infos).toEqual(["info message"]);
+  });
+
+  it("should not cross-contaminate arrays", () => {
+    const { logger, logs, errors, warns, infos } = createTestLogger();
+
+    logger.log("log");
+    expect(errors).toEqual([]);
+    expect(warns).toEqual([]);
+    expect(infos).toEqual([]);
+
+    logger.error("error");
+    expect(logs).toEqual(["log"]);
+    expect(warns).toEqual([]);
+    expect(infos).toEqual([]);
+
+    logger.warn("warn");
+    expect(logs).toEqual(["log"]);
+    expect(errors).toEqual(["error"]);
+    expect(infos).toEqual([]);
+
+    logger.info("info");
+    expect(logs).toEqual(["log"]);
+    expect(errors).toEqual(["error"]);
+    expect(warns).toEqual(["warn"]);
+  });
+});

package/tests/loggerObj.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { logger } from "../src/loggerObj.js";
+import type { Logger } from "../src/loggerObj.js";
+
+describe("Logger interface", () => {
+  it("should have all required methods", () => {
+    expect(logger).toHaveProperty("log");
+    expect(logger).toHaveProperty("error");
+    expect(logger).toHaveProperty("warn");
+    expect(logger).toHaveProperty("info");
+    expect(typeof logger.log).toBe("function");
+    expect(typeof logger.error).toBe("function");
+    expect(typeof logger.warn).toBe("function");
+    expect(typeof logger.info).toBe("function");
+  });
+});
+
+describe("logger.log", () => {
+  let logSpy: any;
+
+  beforeEach(() => {
+    logSpy = spyOn(console, "log");
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("should call console.log with single string", () => {
+    logger.log("test message");
+    expect(logSpy).toHaveBeenCalledWith("test message");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with multiple arguments", () => {
+    logger.log("test", "multiple", "args");
+    expect(logSpy).toHaveBeenCalledWith("test", "multiple", "args");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with number", () => {
+    logger.log(42);
+    expect(logSpy).toHaveBeenCalledWith(42);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with object", () => {
+    const obj = { key: "value" };
+    logger.log(obj);
+    expect(logSpy).toHaveBeenCalledWith(obj);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with array", () => {
+    const arr = [1, 2, 3];
+    logger.log(arr);
+    expect(logSpy).toHaveBeenCalledWith(arr);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with null", () => {
+    logger.log(null);
+    expect(logSpy).toHaveBeenCalledWith(null);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with undefined", () => {
+    logger.log(undefined);
+    expect(logSpy).toHaveBeenCalledWith(undefined);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with boolean", () => {
+    logger.log(true);
+    expect(logSpy).toHaveBeenCalledWith(true);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with mixed types", () => {
+    logger.log("string", 42, { key: "value" }, [1, 2], null, undefined, true);
+    expect(logSpy).toHaveBeenCalledWith(
+      "string",
+      42,
+      { key: "value" },
+      [1, 2],
+      null,
+      undefined,
+      true,
+    );
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with no arguments", () => {
+    logger.log();
+    expect(logSpy).toHaveBeenCalledWith();
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log multiple times independently", () => {
+    logger.log("first");
+    logger.log("second");
+    logger.log("third");
+    expect(logSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it("should call console.log with empty string", () => {
+    logger.log("");
+    expect(logSpy).toHaveBeenCalledWith("");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with zero", () => {
+    logger.log(0);
+    expect(logSpy).toHaveBeenCalledWith(0);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with negative number", () => {
+    logger.log(-42);
+    expect(logSpy).toHaveBeenCalledWith(-42);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with NaN", () => {
+    logger.log(NaN);
+    expect(logSpy).toHaveBeenCalledWith(NaN);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.log with Infinity", () => {
+    logger.log(Infinity);
+    expect(logSpy).toHaveBeenCalledWith(Infinity);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.error", () => {
+  let errorSpy: any;
+
+  beforeEach(() => {
+    errorSpy = spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  it("should call console.error with single string", () => {
+    logger.error("error message");
+    expect(errorSpy).toHaveBeenCalledWith("error message");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with multiple arguments", () => {
+    logger.error("error", "multiple", "args");
+    expect(errorSpy).toHaveBeenCalledWith("error", "multiple", "args");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with Error object", () => {
+    const error = new Error("test error");
+    logger.error(error);
+    expect(errorSpy).toHaveBeenCalledWith(error);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with null", () => {
+    logger.error(null);
+    expect(errorSpy).toHaveBeenCalledWith(null);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with undefined", () => {
+    logger.error(undefined);
+    expect(errorSpy).toHaveBeenCalledWith(undefined);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.error with no arguments", () => {
+    logger.error();
+    expect(errorSpy).toHaveBeenCalledWith();
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.warn", () => {
+  let warnSpy: any;
+
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn");
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("should call console.warn with single string", () => {
+    logger.warn("warning message");
+    expect(warnSpy).toHaveBeenCalledWith("warning message");
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with multiple arguments", () => {
+    logger.warn("warn", "multiple", "args");
+    expect(warnSpy).toHaveBeenCalledWith("warn", "multiple", "args");
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with null", () => {
+    logger.warn(null);
+    expect(warnSpy).toHaveBeenCalledWith(null);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with undefined", () => {
+    logger.warn(undefined);
+    expect(warnSpy).toHaveBeenCalledWith(undefined);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.warn with no arguments", () => {
+    logger.warn();
+    expect(warnSpy).toHaveBeenCalledWith();
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("logger.info", () => {
+  let infoSpy: any;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, "info");
+  });
+
+  afterEach(() => {
+    infoSpy.mockRestore();
+  });
+
+  it("should call console.info with single string", () => {
+    logger.info("info message");
+    expect(infoSpy).toHaveBeenCalledWith("info message");
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with multiple arguments", () => {
+    logger.info("info", "multiple", "args");
+    expect(infoSpy).toHaveBeenCalledWith("info", "multiple", "args");
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with null", () => {
+    logger.info(null);
+    expect(infoSpy).toHaveBeenCalledWith(null);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with undefined", () => {
+    logger.info(undefined);
+    expect(infoSpy).toHaveBeenCalledWith(undefined);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call console.info with no arguments", () => {
+    logger.info();
+    expect(infoSpy).toHaveBeenCalledWith();
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("Logger type compatibility", () => {
+  it("should be compatible with Logger interface", () => {
+    const testLogger: Logger = logger;
+    expect(testLogger).toBeDefined();
+  });
+
+  it("should allow custom Logger implementation", () => {
+    const customLogger: Logger = {
+      log: () => {},
+      error: () => {},
+      warn: () => {},
+      info: () => {},
+    };
+    expect(customLogger).toBeDefined();
+  });
+});

package/tests/silentLogger.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, spyOn, beforeEach, afterEach } from "bun:test";
+import { silentLogger } from "../src/silentLogger.js";
+import type { Logger } from "../src/loggerObj.js";
+
+describe("silentLogger interface", () => {
+  it("should have all required Logger methods", () => {
+    expect(silentLogger).toHaveProperty("log");
+    expect(silentLogger).toHaveProperty("error");
+    expect(silentLogger).toHaveProperty("warn");
+    expect(silentLogger).toHaveProperty("info");
+    expect(typeof silentLogger.log).toBe("function");
+    expect(typeof silentLogger.error).toBe("function");
+    expect(typeof silentLogger.warn).toBe("function");
+    expect(typeof silentLogger.info).toBe("function");
+  });
+
+  it("should be compatible with Logger type", () => {
+    const testLogger: Logger = silentLogger;
+    expect(testLogger).toBeDefined();
+  });
+});
+
+describe("silentLogger.log", () => {
+  let logSpy: any;
+
+  beforeEach(() => {
+    logSpy = spyOn(console, "log");
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+  });
+
+  it("should not call console.log with single string", () => {
+    silentLogger.log("test message");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with multiple arguments", () => {
+    silentLogger.log("test", "multiple", "args");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with object", () => {
+    silentLogger.log({ key: "value" });
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with null", () => {
+    silentLogger.log(null);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with undefined", () => {
+    silentLogger.log(undefined);
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log with no arguments", () => {
+    silentLogger.log();
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.log when called multiple times", () => {
+    silentLogger.log("first");
+    silentLogger.log("second");
+    silentLogger.log("third");
+    expect(logSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.log("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.log("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.error", () => {
+  let errorSpy: any;
+
+  beforeEach(() => {
+    errorSpy = spyOn(console, "error");
+  });
+
+  afterEach(() => {
+    errorSpy.mockRestore();
+  });
+
+  it("should not call console.error with single string", () => {
+    silentLogger.error("error message");
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with multiple arguments", () => {
+    silentLogger.error("error", "multiple", "args");
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with Error object", () => {
+    silentLogger.error(new Error("test error"));
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with null", () => {
+    silentLogger.error(null);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with undefined", () => {
+    silentLogger.error(undefined);
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.error with no arguments", () => {
+    silentLogger.error();
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.error("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.error("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.warn", () => {
+  let warnSpy: any;
+
+  beforeEach(() => {
+    warnSpy = spyOn(console, "warn");
+  });
+
+  afterEach(() => {
+    warnSpy.mockRestore();
+  });
+
+  it("should not call console.warn with single string", () => {
+    silentLogger.warn("warning message");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with multiple arguments", () => {
+    silentLogger.warn("warn", "multiple", "args");
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with null", () => {
+    silentLogger.warn(null);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with undefined", () => {
+    silentLogger.warn(undefined);
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.warn with no arguments", () => {
+    silentLogger.warn();
+    expect(warnSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.warn("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.warn("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger.info", () => {
+  let infoSpy: any;
+
+  beforeEach(() => {
+    infoSpy = spyOn(console, "info");
+  });
+
+  afterEach(() => {
+    infoSpy.mockRestore();
+  });
+
+  it("should not call console.info with single string", () => {
+    silentLogger.info("info message");
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with multiple arguments", () => {
+    silentLogger.info("info", "multiple", "args");
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with null", () => {
+    silentLogger.info(null);
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with undefined", () => {
+    silentLogger.info(undefined);
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not call console.info with no arguments", () => {
+    silentLogger.info();
+    expect(infoSpy).not.toHaveBeenCalled();
+  });
+
+  it("should not throw when called", () => {
+    expect(() => silentLogger.info("test")).not.toThrow();
+  });
+
+  it("should return undefined", () => {
+    const result = silentLogger.info("test");
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("silentLogger behavior", () => {
+  it("should not produce any console output when all methods are called", () => {
+    const logSpy = spyOn(console, "log");
+    const errorSpy = spyOn(console, "error");
+    const warnSpy = spyOn(console, "warn");
+    const infoSpy = spyOn(console, "info");
+
+    silentLogger.log("test");
+    silentLogger.error("test");
+    silentLogger.warn("test");
+    silentLogger.info("test");
+
+    expect(logSpy).not.toHaveBeenCalled();
+    expect(errorSpy).not.toHaveBeenCalled();
+    expect(warnSpy).not.toHaveBeenCalled();
+    expect(infoSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    warnSpy.mockRestore();
+    infoSpy.mockRestore();
+  });
+});