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/ExpressionsCompiler.spec.ts

@@ -4,22 +4,23 @@ import { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressi
 import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
 import { ExpressionParserStub } from '@tests/unit/shared/Stubs/ExpressionParserStub';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
-import { itEachAbsentObjectValue, itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
 
 describe('ExpressionsCompiler', () => {
   describe('compileExpressions', () => {
-    describe('returns code when code is absent', () => {
+    describe('returns empty string when code is absent', () => {
       itEachAbsentStringValue((absentValue) => {
         // arrange
-        const expected = absentValue;
+        const expected = '';
+        const code = absentValue;
         const sut = new SystemUnderTest();
         const args = new FunctionCallArgumentCollectionStub();
         // act
-        const value = sut.compileExpressions(absentValue, args);
+        const value = sut.compileExpressions(code, args);
         // assert
         expect(value).to.equal(expected);
-      });
+      }, { excludeNull: true, excludeUndefined: true });
     });
     describe('can compile nested expressions', () => {
       it('when one expression is evaluated to a text that contains another expression', () => {
@@ -189,19 +190,6 @@ describe('ExpressionsCompiler', () => {
           + `Not equal: ${actualArgs.filter((arg) => arg !== expected)}`,
         );
       });
-      describe('throws if arguments is missing', () => {
-        itEachAbsentObjectValue((absentValue) => {
-          // arrange
-          const expectedError = 'missing args, send empty collection instead.';
-          const args = absentValue;
-          const expressionParserMock = new ExpressionParserStub();
-          const sut = new SystemUnderTest(expressionParserMock);
-          // act
-          const act = () => sut.compileExpressions('code', args);
-          // assert
-          expect(act).to.throw(expectedError);
-        });
-      });
     });
     describe('throws when expressions are invalid', () => {
       describe('throws when expected argument is not provided but used in code', () => {