Centralize log file and refactor desktop logging

- Migrate to `electron-log` v5.X.X, centralizing log files to adhere to
  best-practices.
- Add critical event logging in the log file.
- Replace `ElectronLog` type with `LogFunctions` for better abstraction.
- Unify log handling in `desktop-runtime-error` by removing
  `renderer.log` due to `electron-log` v5 changes.
- Update and extend logger interfaces, removing 'I' prefix and adding
  common log levels to abstract `electron-log` completely.
- Move logger interfaces to the application layer as it's cross-cutting
  concern, meanwhile keeping the implementations in the infrastructure
  layer.
- Introduce `useLogger` hook for easier logging in Vue components.
- Simplify `WindowVariables` by removing nullable properties.
- Improve documentation to clearly differentiate between desktop and web
  versions, outlining specific features of each.

src/infrastructure/Log/ConsoleLogger.ts

@@ -1,17 +1,32 @@
-import { ILogger } from './ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
-export class ConsoleLogger implements ILogger {
-  constructor(private readonly consoleProxy: Partial<Console> = console) {
+export class ConsoleLogger implements Logger {
+  constructor(private readonly consoleProxy: ConsoleLogFunctions = globalThis.console) {
     if (!consoleProxy) { // do not trust strictNullChecks for global objects
       throw new Error('missing console');
     }
   }
 
   public info(...params: unknown[]): void {
-    const logFunction = this.consoleProxy?.info;
-    if (!logFunction) {
-      throw new Error('missing "info" function');
-    }
-    logFunction.call(this.consoleProxy, ...params);
+    this.consoleProxy.info(...params);
+  }
+
+  public warn(...params: unknown[]): void {
+    this.consoleProxy.warn(...params);
+  }
+
+  public error(...params: unknown[]): void {
+    this.consoleProxy.error(...params);
+  }
+
+  public debug(...params: unknown[]): void {
+    this.consoleProxy.debug(...params);
   }
 }
+
+interface ConsoleLogFunctions extends Partial<Console> {
+  readonly info: Console['info'];
+  readonly warn: Console['warn'];
+  readonly error: Console['error'];
+  readonly debug: Console['debug'];
+}

src/infrastructure/Log/ElectronLogger.ts

@@ -1,17 +1,15 @@
-import { ElectronLog } from 'electron-log';
-import { ILogger } from './ILogger';
+import log from 'electron-log/main';
+import { Logger } from '@/application/Common/Log/Logger';
+import type { LogFunctions } from 'electron-log';
 
 // Using plain-function rather than class so it can be used in Electron's context-bridging.
-export function createElectronLogger(logger: Partial<ElectronLog>): ILogger {
-  if (!logger) {
-    throw new Error('missing logger');
-  }
+export function createElectronLogger(logger: LogFunctions = log): Logger {
   return {
-    info: (...params) => {
-      if (!logger.info) {
-        throw new Error('missing "info" function');
-      }
-      logger.info(...params);
-    },
+    info: (...params) => logger.info(...params),
+    debug: (...params) => logger.debug(...params),
+    warn: (...params) => logger.warn(...params),
+    error: (...params) => logger.error(...params),
   };
 }
+
+export const ElectronLogger = createElectronLogger();

src/infrastructure/Log/ILogger.ts

@@ -1,3 +0,0 @@
-export interface ILogger {
-  info (...params: unknown[]): void;
-}

src/infrastructure/Log/ILoggerFactory.ts

@@ -1,5 +0,0 @@
-import { ILogger } from './ILogger';
-
-export interface ILoggerFactory {
-  readonly logger: ILogger;
-}

src/infrastructure/Log/NoopLogger.ts

@@ -1,5 +1,11 @@
-import { ILogger } from './ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
-export class NoopLogger implements ILogger {
+export class NoopLogger implements Logger {
   public info(): void { /* NOOP */ }
+
+  public warn(): void { /* NOOP */ }
+
+  public error(): void { /* NOOP */ }
+
+  public debug(): void { /* NOOP */ }
 }

src/infrastructure/Log/WindowInjectedLogger.ts

@@ -1,8 +1,8 @@
+import { Logger } from '@/application/Common/Log/Logger';
 import { WindowVariables } from '../WindowVariables/WindowVariables';
-import { ILogger } from './ILogger';
 
-export class WindowInjectedLogger implements ILogger {
-  private readonly logger: ILogger;
+export class WindowInjectedLogger implements Logger {
+  private readonly logger: Logger;
 
   constructor(windowVariables: WindowVariables | undefined | null = window) {
     if (!windowVariables) { // do not trust strict null checks for global objects
@@ -17,4 +17,16 @@ export class WindowInjectedLogger implements ILogger {
   public info(...params: unknown[]): void {
     this.logger.info(...params);
   }
+
+  public warn(...params: unknown[]): void {
+    this.logger.warn(...params);
+  }
+
+  public debug(...params: unknown[]): void {
+    this.logger.debug(...params);
+  }
+
+  public error(...params: unknown[]): void {
+    this.logger.error(...params);
+  }
 }

src/infrastructure/WindowVariables/WindowVariables.ts

@@ -1,11 +1,11 @@
 import { OperatingSystem } from '@/domain/OperatingSystem';
 import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 
 /* Primary entry point for platform-specific injections */
 export interface WindowVariables {
-  readonly isDesktop?: boolean;
+  readonly isDesktop: boolean;
   readonly system?: ISystemOperations;
   readonly os?: OperatingSystem;
-  readonly log?: ILogger;
+  readonly log: Logger;
 }