Bump to TypeScript 5.5 and enable noImplicitAny

This commit upgrades TypeScript from 5.4 to 5.5 and enables the
`noImplicitAny` option for stricter type checking. It refactors code to
comply with `noImplicitAny` and adapts to new TypeScript features and
limitations.

Key changes:

- Migrate from TypeScript 5.4 to 5.5
- Enable `noImplicitAny` for stricter type checking
- Refactor code to comply with new TypeScript features and limitations

Other supporting changes:

- Refactor progress bar handling for type safety
- Drop 'I' prefix from interfaces to align with new code convention
- Update TypeScript target from `ES2017` and `ES2018`.
  This allows named capturing groups. Otherwise, new TypeScript compiler
  does not compile the project and shows the following error:
  ```
  ...
  TimestampedFilenameGenerator.spec.ts:105:23 - error TS1503: Named capturing groups are only available when targeting 'ES2018' or later
  const pattern = /^(?<timestamp>\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})-(?<scriptName>[^.]+?)(?:\.(?<extension>[^.]+))?$/;// timestamp-scriptName.extension
  ...
  ```
- Refactor usage of `electron-progressbar` for type safety and
  less complexity.

tests/unit/application/Parser/Common/TypeValidator.spec.ts

@@ -135,7 +135,7 @@ describe('createTypeValidator', () => {
       });
       it('throws error for empty collection', () => {
         // arrange
-        const emptyArrayValue = [];
+        const emptyArrayValue: unknown[] = [];
         const valueName = 'empty collection value';
         const expectedMessage = `'${valueName}' cannot be an empty array.`;
         const { assertNonEmptyCollection } = createTypeValidator();
@@ -251,7 +251,7 @@ describe('createTypeValidator', () => {
 });
 
 function createObjectWithProperties(properties: readonly string[]): object {
-  const object = {};
+  const object: Record<string, unknown> = {};
   properties.forEach((propertyName) => {
     object[propertyName] = 'arbitrary value';
   });

tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts

@@ -383,7 +383,7 @@ function createExpressionFactorySpy() {
   };
   return {
     createExpression,
-    getInitParameters: (expression) => createdExpressions.get(expression),
+    getInitParameters: (expression: IExpression) => createdExpressions.get(expression),
   };
 }
 

tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory.spec.ts

@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { PipeFactory } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipeFactory';
 import { PipeStub } from '@tests/unit/shared/Stubs/PipeStub';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
+import type { Pipe } from '@/application/Parser/Executable/Script/Compiler/Expressions/Pipes/Pipe';
 
 describe('PipeFactory', () => {
   describe('ctor', () => {
@@ -49,7 +50,7 @@ describe('PipeFactory', () => {
       // arrange
       const missingName = 'missingName';
       const expectedError = `Unknown pipe: "${missingName}"`;
-      const pipes = [];
+      const pipes: readonly Pipe[] = [];
       const sut = new PipeFactory(pipes);
       // act
       const act = () => sut.get(missingName);

tests/unit/application/Parser/Executable/Script/Compiler/Expressions/Pipes/PipelineCompiler.spec.ts

@@ -9,20 +9,20 @@ import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTes
 describe('PipelineCompiler', () => {
   describe('compile', () => {
     describe('throws for invalid arguments', () => {
-      interface ITestCase {
+      interface ThrowingPipeScenario {
         readonly name: string;
         readonly act: (test: PipelineTestRunner) => PipelineTestRunner;
         readonly expectedError: string;
       }
-      const testCases: ITestCase[] = [
+      const testScenarios: ThrowingPipeScenario[] = [
         ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
-          .map((testCase) => ({
+          .map((testCase): ThrowingPipeScenario => ({
             name: `"value" is ${testCase.valueName}`,
             act: (test) => test.withValue(testCase.absentValue),
             expectedError: 'missing value',
           })),
         ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
-          .map((testCase) => ({
+          .map((testCase): ThrowingPipeScenario => ({
             name: `"pipeline" is ${testCase.valueName}`,
             act: (test) => test.withPipeline(testCase.absentValue),
             expectedError: 'missing pipeline',
@@ -33,7 +33,7 @@ describe('PipelineCompiler', () => {
           expectedError: 'pipeline does not start with pipe',
         },
       ];
-      for (const testCase of testCases) {
+      for (const testCase of testScenarios) {
         it(testCase.name, () => {
           // act
           const runner = new PipelineTestRunner();

tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/SyntaxParserTestsRunner.ts

@@ -114,7 +114,7 @@ export class SyntaxParserTestsRunner {
   }
 }
 
-interface ExpectResultTestScenario {
+export interface ExpectResultTestScenario {
   readonly name: string;
   readonly code: string;
   readonly args: (

tests/unit/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser.spec.ts

@@ -2,7 +2,7 @@ import { describe } from 'vitest';
 import { ExpressionPosition } from '@/application/Parser/Executable/Script/Compiler/Expressions/Expression/ExpressionPosition';
 import { WithParser } from '@/application/Parser/Executable/Script/Compiler/Expressions/SyntaxParsers/WithParser';
 import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
-import { SyntaxParserTestsRunner } from './SyntaxParserTestsRunner';
+import { SyntaxParserTestsRunner, type ExpectResultTestScenario } from './SyntaxParserTestsRunner';
 
 describe('WithParser', () => {
   const sut = new WithParser();
@@ -120,7 +120,7 @@ describe('WithParser', () => {
       describe('does not render scope', () => {
         runner.expectResults(
           ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
-            .map((testCase) => ({
+            .map((testCase): ExpectResultTestScenario => ({
               name: `does not render when value is "${testCase.valueName}"`,
               code: '{{ with $parameter }}dark{{ end }} ',
               args: (args) => args
@@ -138,7 +138,7 @@ describe('WithParser', () => {
       describe('renders scope', () => {
         runner.expectResults(
           ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
-            .map((testCase) => ({
+            .map((testCase): ExpectResultTestScenario => ({
               name: `does not render when value is "${testCase.valueName}"`,
               code: '{{ with $parameter }}dark{{ end }} ',
               args: (args) => args

tests/unit/application/Parser/Executable/Script/Validation/Analyzers/AnalyzeTooLongLines.spec.ts

@@ -165,11 +165,14 @@ function createScriptLanguageScenarios(): readonly ScriptLanguageScenario[] {
     [ScriptingLanguage.batchfile]: 8191,
     [ScriptingLanguage.shellscript]: 1048576,
   };
-  return Object.entries(maxLengths).map(([language, length]): ScriptLanguageScenario => ({
-    description: `${ScriptingLanguage[language]} (max: ${length})`,
-    language: Number.parseInt(language, 10) as ScriptingLanguage,
-    maxLength: length,
-  }));
+  return Object.entries(maxLengths).map(([language, length]): ScriptLanguageScenario => {
+    const languageValue = Number.parseInt(language, 10) as ScriptingLanguage;
+    return {
+      description: `${ScriptingLanguage[languageValue]} (max: ${length})`,
+      language: languageValue,
+      maxLength: length,
+    };
+  });
 }
 
 class TestContext {