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.

tests/unit/infrastructure/Log/ConsoleLogger.spec.ts

@@ -32,21 +32,6 @@ describe('ConsoleLogger', () => {
       expect(consoleMock.callHistory[0].args).to.deep.equal(expectedParams);
     });
   });
-  describe('throws if log function is missing', () => {
-    itEachLoggingMethod((functionName, testParameters) => {
-      // arrange
-      const expectedError = `missing "${functionName}" function`;
-      const consoleMock = {} as Partial<Console>;
-      consoleMock[functionName] = undefined;
-      const logger = new ConsoleLogger(consoleMock);
-
-      // act
-      const act = () => logger[functionName](...testParameters);
-
-      // assert
-      expect(act).to.throw(expectedError);
-    });
-  });
 });
 
 class MockConsole
@@ -58,4 +43,25 @@ class MockConsole
       args,
     });
   }
+
+  public warn(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'warn',
+      args,
+    });
+  }
+
+  public debug(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'debug',
+      args,
+    });
+  }
+
+  public error(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'error',
+      args,
+    });
+  }
 }

tests/unit/infrastructure/Log/ElectronLogger.spec.ts

@@ -1,42 +1,15 @@
 import { describe, expect } from 'vitest';
-import { ElectronLog } from 'electron-log';
 import { StubWithObservableMethodCalls } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
 import { createElectronLogger } from '@/infrastructure/Log/ElectronLogger';
-import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { itEachLoggingMethod } from './LoggerTestRunner';
+import type { LogFunctions } from 'electron-log';
 
 describe('ElectronLogger', () => {
-  describe('throws if logger is missing', () => {
-    itEachAbsentObjectValue((absentValue) => {
-      // arrange
-      const expectedError = 'missing logger';
-      const electronLog = absentValue as never;
-      // act
-      const act = () => createElectronLogger(electronLog);
-      // assert
-      expect(act).to.throw(expectedError);
-    }, { excludeUndefined: true });
-  });
-  describe('throws if log function is missing', () => {
-    itEachLoggingMethod((functionName, testParameters) => {
-      // arrange
-      const expectedError = `missing "${functionName}" function`;
-      const electronLogMock = {} as Partial<ElectronLog>;
-      electronLogMock[functionName] = undefined;
-      const logger = createElectronLogger(electronLogMock);
-
-      // act
-      const act = () => logger[functionName](...testParameters);
-
-      // assert
-      expect(act).to.throw(expectedError);
-    });
-  });
   describe('methods log the provided params', () => {
     itEachLoggingMethod((functionName, testParameters) => {
       // arrange
       const expectedParams = testParameters;
-      const electronLogMock = new MockElectronLog();
+      const electronLogMock = new ElectronLogStub();
       const logger = createElectronLogger(electronLogMock);
 
       // act
@@ -50,9 +23,51 @@ describe('ElectronLogger', () => {
   });
 });
 
-class MockElectronLog
-  extends StubWithObservableMethodCalls<ElectronLog>
-  implements Partial<ElectronLog> {
+class ElectronLogStub
+  extends StubWithObservableMethodCalls<LogFunctions>
+  implements LogFunctions {
+  public error(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'error',
+      args,
+    });
+  }
+
+  public warn(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'warn',
+      args,
+    });
+  }
+
+  public verbose(...args: unknown[]): void {
+    this.registerMethodCall({
+      methodName: 'verbose',
+      args,
+    });
+  }
+
+  public debug(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'debug',
+      args,
+    });
+  }
+
+  public silly(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'silly',
+      args,
+    });
+  }
+
+  public log(...args: unknown[]) {
+    this.registerMethodCall({
+      methodName: 'log',
+      args,
+    });
+  }
+
   public info(...args: unknown[]) {
     this.registerMethodCall({
       methodName: 'info',

tests/unit/infrastructure/Log/LoggerTestRunner.ts

@@ -1,23 +1,25 @@
 import { it } from 'vitest';
-import { FunctionKeys } from '@/TypeHelpers';
-import { ILogger } from '@/infrastructure/Log/ILogger';
-
-type TestParameters = [string, number, { some: string }];
+import { Logger } from '@/application/Common/Log/Logger';
 
 export function itEachLoggingMethod(
   handler: (
-    functionName: keyof ILogger,
-    testParameters: TestParameters,
+    functionName: keyof Logger,
+    testParameters: readonly unknown[]
   ) => void,
 ) {
-  const testParameters: TestParameters = ['test', 123, { some: 'object' }];
-  const loggerMethods: Array<FunctionKeys<ILogger>> = [
-    'info',
-  ];
-  loggerMethods
-    .forEach((functionKey) => {
+  const testScenarios: {
+    readonly [FunctionName in keyof Logger]: Parameters<Logger[FunctionName]>;
+  } = {
+    info: ['single-string'],
+    warn: ['with number', 123],
+    debug: ['with simple object', { some: 'object' }],
+    error: ['with error object', new Error('error')],
+  };
+
+  Object.entries(testScenarios)
+    .forEach(([functionKey, testParameters]) => {
       it(functionKey, () => {
-        handler(functionKey, testParameters);
+        handler(functionKey as keyof Logger, testParameters);
       });
     });
 }

tests/unit/infrastructure/Log/NoopLogger.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from 'vitest';
 import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
-import { ILogger } from '@/infrastructure/Log/ILogger';
+import { Logger } from '@/application/Common/Log/Logger';
 import { itEachLoggingMethod } from './LoggerTestRunner';
 
 describe('NoopLogger', () => {
@@ -8,7 +8,7 @@ describe('NoopLogger', () => {
     itEachLoggingMethod((functionName, testParameters) => {
       // arrange
       const randomParams = testParameters;
-      const logger: ILogger = new NoopLogger();
+      const logger: Logger = new NoopLogger();
 
       // act
       const act = () => logger[functionName](...randomParams);

tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts

@@ -177,10 +177,11 @@ function expectObjectOnDesktop<T>(key: keyof WindowVariables) {
   describe('does not object type when not on desktop', () => {
     itEachInvalidObjectValue((invalidObjectValue) => {
       // arrange
+      const isOnDesktop = false;
       const invalidObject = invalidObjectValue as T;
       const input: WindowVariables = {
         ...new WindowVariablesStub(),
-        isDesktop: undefined,
+        isDesktop: isOnDesktop,
         [key]: invalidObject,
       };
       // act