Refactor to enforce strictNullChecks

This commit applies `strictNullChecks` to the entire codebase to improve
maintainability and type safety. Key changes include:

- Remove some explicit null-checks where unnecessary.
- Add necessary null-checks.
- Refactor static factory functions for a more functional approach.
- Improve some test names and contexts for better debugging.
- Add unit tests for any additional logic introduced.
- Refactor `createPositionFromRegexFullMatch` to its own function as the
  logic is reused.
- Prefer `find` prefix on functions that may return `undefined` and
  `get` prefix for those that always return a value.

tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/EscapeDoubleQuotes.spec.ts

@@ -8,6 +8,12 @@ describe('EscapeDoubleQuotes', () => {
   const sut = new EscapeDoubleQuotes();
   // act
   runPipeTests(sut, [
+    ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
+      .map((testCase) => ({
+        name: 'returns as it is when if input is missing',
+        input: testCase.absentValue,
+        expectedOutput: testCase.absentValue,
+      })),
     {
       name: 'using "',
       input: 'hello "world"',
@@ -23,10 +29,5 @@ describe('EscapeDoubleQuotes', () => {
       input: '""hello world""',
       expectedOutput: '"^"""^""hello world"^"""^""',
     },
-    ...getAbsentStringTestCases().map((testCase) => ({
-      name: 'returns as it is when if input is missing',
-      input: testCase.absentValue,
-      expectedOutput: testCase.absentValue,
-    })),
   ]);
 });

tests/unit/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell.spec.ts

@@ -1,5 +1,6 @@
 import { describe } from 'vitest';
 import { InlinePowerShell } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeDefinitions/InlinePowerShell';
+import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 import { IPipeTestCase, runPipeTests } from './PipeTestRunner';
 
 describe('InlinePowerShell', () => {
@@ -7,11 +8,12 @@ describe('InlinePowerShell', () => {
   const sut = new InlinePowerShell();
   // act
   runPipeTests(sut, [
-    {
-      name: 'returns undefined when if input is undefined',
-      input: undefined,
-      expectedOutput: undefined,
-    },
+    ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
+      .map((testCase) => ({
+        name: 'returns as it is when if input is missing',
+        input: testCase.absentValue,
+        expectedOutput: '',
+      })),
     ...prefixTests('newline', getNewLineCases()),
     ...prefixTests('comment', getCommentCases()),
     ...prefixTests('here-string', hereStringCases()),

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

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { PipeFactory } from '@/application/Parser/Script/Compiler/Expressions/Pipes/PipeFactory';
 import { PipeStub } from '@tests/unit/shared/Stubs/PipeStub';
-import { getAbsentStringTestCases, itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
 
 describe('PipeFactory', () => {
   describe('ctor', () => {
@@ -19,26 +19,6 @@ describe('PipeFactory', () => {
       // expect
       expect(act).to.throw(expectedError);
     });
-    describe('throws when a pipe is missing', () => {
-      itEachAbsentObjectValue((absentValue) => {
-        // arrange
-        const expectedError = 'missing pipe in list';
-        const pipes = [new PipeStub(), absentValue];
-        // act
-        const act = () => new PipeFactory(pipes);
-        // expect
-        expect(act).to.throw(expectedError);
-      });
-    });
-    it('throws when pipes are null', () => {
-      // arrange
-      const expectedError = 'missing pipes';
-      const pipes = null;
-      // act
-      const act = () => new PipeFactory(pipes);
-      // expect
-      expect(act).to.throw(expectedError);
-    });
     describe('throws when name is invalid', () => {
       // act
       const act = (invalidName: string) => new PipeFactory([new PipeStub().withName(invalidName)]);
@@ -82,11 +62,12 @@ describe('PipeFactory', () => {
 function testPipeNameValidation(testRunner: (invalidName: string) => void) {
   const testCases = [
     // Validate missing value
-    ...getAbsentStringTestCases().map((testCase) => ({
-      name: `empty pipe name (${testCase.valueName})`,
-      value: testCase.absentValue,
-      expectedError: 'empty pipe name',
-    })),
+    ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
+      .map((testCase) => ({
+        name: `empty pipe name (${testCase.valueName})`,
+        value: testCase.absentValue,
+        expectedError: 'empty pipe name',
+      })),
     // Validate camelCase
     ...[
       'PascalCase',

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

@@ -10,21 +10,23 @@ describe('PipelineCompiler', () => {
   describe('compile', () => {
     describe('throws for invalid arguments', () => {
       interface ITestCase {
-        name: string;
-        act: (test: PipelineTestRunner) => PipelineTestRunner;
-        expectedError: string;
+        readonly name: string;
+        readonly act: (test: PipelineTestRunner) => PipelineTestRunner;
+        readonly expectedError: string;
       }
       const testCases: ITestCase[] = [
-        ...getAbsentStringTestCases().map((testCase) => ({
-          name: `"value" is ${testCase.valueName}`,
-          act: (test) => test.withValue(testCase.absentValue),
-          expectedError: 'missing value',
-        })),
-        ...getAbsentStringTestCases().map((testCase) => ({
-          name: `"pipeline" is ${testCase.valueName}`,
-          act: (test) => test.withPipeline(testCase.absentValue),
-          expectedError: 'missing pipeline',
-        })),
+        ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
+          .map((testCase) => ({
+            name: `"value" is ${testCase.valueName}`,
+            act: (test) => test.withValue(testCase.absentValue),
+            expectedError: 'missing value',
+          })),
+        ...getAbsentStringTestCases({ excludeNull: true, excludeUndefined: true })
+          .map((testCase) => ({
+            name: `"pipeline" is ${testCase.valueName}`,
+            act: (test) => test.withPipeline(testCase.absentValue),
+            expectedError: 'missing pipeline',
+          })),
         {
           name: '"pipeline" does not start with pipe',
           act: (test) => test.withPipeline('pipeline |'),