@vvlad1973/simple-logger 1.2.0 → 1.2.2

package/src/__test__/simple-logger.test.ts

@@ -1,51 +1,25 @@
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'assert';
+import { describe, it, beforeEach, expect, vi } from 'vitest';
 import SimpleLogger from '../simple-logger.js';
 
-type MockFunction = {
-  (...args: any[]): void;
-  mock: { calls: any[][] };
-};
-
-type NoopFunction = {
-  (...args: any[]): void;
-  mock: { calls: any[][] };
-};
-
-function createMockLoggerMethod(): MockFunction {
-  const calls: any[][] = [];
-  const mockFn = function (...args: any[]) {
-    calls.push(args);
-  } as MockFunction;
-  mockFn.mock = { calls };
-  return mockFn;
-}
-
-function createNoopMethod(): MockFunction {
-  const calls: any[][] = [];
-  const mockFn = function (...args: any[]) {} as MockFunction;
-  mockFn.mock = { calls };
-  return mockFn;
-}
 type ExternalLoggerMock = {
-  trace: MockFunction | NoopFunction;
-  debug: MockFunction | NoopFunction;
-  info: MockFunction | NoopFunction;
-  warn: MockFunction | NoopFunction;
-  error: MockFunction | NoopFunction;
-  fatal: MockFunction | NoopFunction;
-  silent: MockFunction | NoopFunction;
+  trace: ReturnType<typeof vi.fn>;
+  debug: ReturnType<typeof vi.fn>;
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  fatal: ReturnType<typeof vi.fn>;
+  silent: ReturnType<typeof vi.fn>;
 };
 
 function createExternalLoggerMock(): ExternalLoggerMock {
   return {
-    trace: createMockLoggerMethod(),
-    debug: createMockLoggerMethod(),
-    info: createMockLoggerMethod(),
-    warn: createMockLoggerMethod(),
-    error: createMockLoggerMethod(),
-    fatal: createMockLoggerMethod(),
-    silent:createMockLoggerMethod(),
+    trace: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    silent: vi.fn(),
   };
 }
 
@@ -66,107 +40,20 @@ describe('SimpleLogger', () => {
     logger.error('error message');
     logger.fatal('fatal message');
 
-    assert.strictEqual(externalLoggerMock.trace.mock.calls.length, 0);
-    assert.strictEqual(externalLoggerMock.debug.mock.calls.length, 0);
-    assert.strictEqual(externalLoggerMock.info.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.info.mock.calls[0][0],
-      'info message'
-    );
-    assert.strictEqual(externalLoggerMock.warn.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.warn.mock.calls[0][0],
-      'warn message'
-    );
-    assert.strictEqual(externalLoggerMock.error.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.error.mock.calls[0][0],
-      'error message'
-    );
-    assert.strictEqual(externalLoggerMock.fatal.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.fatal.mock.calls[0][0],
-      'fatal message'
-    );
-  });
-
-  it('should log function start and end', () => {
-    logger.setLevel('TRACE');
-
-    function testFunction() {
-      logger.logFunctionStart();
-      logger.logFunctionEnd();
-    }
-
-    testFunction();
-
-    assert.strictEqual(externalLoggerMock.trace.mock.calls.length, 2);
-    assert.strictEqual(
-      externalLoggerMock.trace.mock.calls[0][0],
-      'Function start: testFunction'
-    );
-    assert.strictEqual(
-      externalLoggerMock.trace.mock.calls[1][0],
-      'Function end: testFunction'
-    );
-  });
-});
-
-describe('SimpleLogger2', () => {
-  let logger: SimpleLogger;
-  let externalLoggerMock: ExternalLoggerMock;
-
-  beforeEach(() => {
-    externalLoggerMock = createExternalLoggerMock();
-    logger = new SimpleLogger('info', externalLoggerMock);
-  });
-
-  it('should use console as default external logger', () => {
-    const defaultLogger = new SimpleLogger();
-    assert.ok(defaultLogger);
-  });
-
-  it('should set the correct log level', () => {
-    logger.setLevel('DEBUG');
-    assert.notStrictEqual(logger.trace, () => {});
-    assert.strictEqual(typeof logger.debug, 'function');
-    assert.strictEqual(typeof logger.info, 'function');
-  });
-
-  it('should call external logger methods appropriately', () => {
-    logger.trace('trace message');
-    logger.debug('debug message');
-    logger.info('info message');
-    logger.warn('warn message');
-    logger.error('error message');
-    logger.fatal('fatal message');
-
-    assert.strictEqual(externalLoggerMock.trace.mock.calls.length, 0); // because default level is INFO
-    assert.strictEqual(externalLoggerMock.debug.mock.calls.length, 0); // because default level is INFO
-    assert.strictEqual(externalLoggerMock.info.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.info.mock.calls[0][0],
-      'info message'
-    );
-    assert.strictEqual(externalLoggerMock.warn.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.warn.mock.calls[0][0],
-      'warn message'
-    );
-    assert.strictEqual(externalLoggerMock.error.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.error.mock.calls[0][0],
-      'error message'
-    );
-    assert.strictEqual(externalLoggerMock.fatal.mock.calls.length, 1);
-    assert.strictEqual(
-      externalLoggerMock.fatal.mock.calls[0][0],
-      'fatal message'
-    );
+    expect(externalLoggerMock.trace).not.toHaveBeenCalled();
+    expect(externalLoggerMock.debug).not.toHaveBeenCalled();
+    expect(externalLoggerMock.info).toHaveBeenCalledTimes(1);
+    expect(externalLoggerMock.info).toHaveBeenCalledWith('info message');
+    expect(externalLoggerMock.warn).toHaveBeenCalledTimes(1);
+    expect(externalLoggerMock.warn).toHaveBeenCalledWith('warn message');
+    expect(externalLoggerMock.error).toHaveBeenCalledTimes(1);
+    expect(externalLoggerMock.error).toHaveBeenCalledWith('error message');
+    expect(externalLoggerMock.fatal).toHaveBeenCalledTimes(1);
+    expect(externalLoggerMock.fatal).toHaveBeenCalledWith('fatal message');
   });
 
   it('should log function start and end', () => {
-    logger.setLevel('TRACE');
+    logger.setLevel('trace');
 
     function testFunction() {
       logger.logFunctionStart();
@@ -175,14 +62,8 @@ describe('SimpleLogger2', () => {
 
     testFunction();
 
-    assert.strictEqual(externalLoggerMock.trace.mock.calls.length, 2);
-    assert.strictEqual(
-      externalLoggerMock.trace.mock.calls[0][0],
-      'Function start: testFunction'
-    );
-    assert.strictEqual(
-      externalLoggerMock.trace.mock.calls[1][0],
-      'Function end: testFunction'
-    );
+    expect(externalLoggerMock.trace).toHaveBeenCalledTimes(2);
+    expect(externalLoggerMock.trace).toHaveBeenCalledWith('Function start: testFunction');
+    expect(externalLoggerMock.trace).toHaveBeenCalledWith('Function end: testFunction');
   });
 });

package/src/simple-logger.ts

@@ -31,6 +31,7 @@ const loggerLevels = [
   'fatal',
   'silent',
 ] as const;
+
 export type LoggerLevel = (typeof loggerLevels)[number];
 /**
  * A simple logger class with various logging levels.
@@ -61,28 +62,23 @@ export class SimpleLogger {
   fatal: LogFn = (...args: any[]) => {};
   silent: LogFn = (...args: any[]) => {};
 
+  private static readonly noop: LogFn = (...args: any[]) => {};
+
   /**
    * Updates the logging methods based on the current logging level.
    * @private
    */
   private updateLoggingMethods() {
     try {
-      const noop = (...args: any[]) => {};
-      this.trace =
-        this.#currentLevel <= 0 ? this.getExternalLoggerMethod('trace') : noop;
-      this.debug =
-        this.#currentLevel <= 1 ? this.getExternalLoggerMethod('debug') : noop;
-      this.info =
-        this.#currentLevel <= 2 ? this.getExternalLoggerMethod('info') : noop;
-      this.warn =
-        this.#currentLevel <= 3 ? this.getExternalLoggerMethod('warn') : noop;
-      this.error =
-        this.#currentLevel <= 4 ? this.getExternalLoggerMethod('error') : noop;
-      this.fatal =
-        this.#currentLevel <= 5
-          ? this.getExternalLoggerMethod('fatal', 'error')
-          : noop;
-      this.silent = noop;
+      this.#levels.forEach((level, index) => {
+        this[level] =
+          this.#currentLevel <= index
+            ? this.getExternalLoggerMethod(
+                level,
+                level === 'fatal' ? 'error' : undefined
+              )
+            : SimpleLogger.noop;
+      });
     } catch (error) {
       console.error(error);
     }
@@ -95,16 +91,18 @@ export class SimpleLogger {
    * @returns {boolean} - True if the logger is valid, otherwise false.
    */
   private isValidLogger(logger: any): boolean {
-    return loggerLevels.every((method) => {
-      return typeof logger[method] === 'function';
-    });
+    return (
+      typeof logger === 'object' &&
+      logger !== null &&
+      loggerLevels.some((level) => typeof logger[level] === 'function')
+    );
   }
 
   /**
    * Gets the external logger method for a specific level.
    * @param {string} method - The logger method to get.
    * @param {string} [fallbackMethod] - The fallback logger method to get.
-   * @returns {LoggerMethod} - The logger method or a no-op function.
+   * @returns {LogFn} - The logger method or a no-op function.
    * @private
    */
   private getExternalLoggerMethod(
@@ -125,10 +123,10 @@ export class SimpleLogger {
           return fallbackLoggerMethod.bind(this.#logger);
         }
       }
-      return () => {};
+      return SimpleLogger.noop;
     } catch (error) {
       console.error(error);
-      return () => {};
+      return SimpleLogger.noop;
     }
   }
 
@@ -163,7 +161,11 @@ export class SimpleLogger {
       this.#logger = console;
       this.isExternal = false;
     }
-    this.setLevel(level ?? logger?.level ?? this.#levels[this.#currentLevel]);
+    this.setLevel(
+      level ??
+        (logger?.level as LoggerLevel) ??
+        this.#levels[this.#currentLevel]
+    );
   }
 
   /**

package/typedoc.json

@@ -0,0 +1,8 @@
+{
+  "entryPoints": [
+    "src/index.ts"
+  ],
+  "out": "docs",
+  "includeVersion": true,
+
+}