@futdevpro/fsm-dynamo 1.10.36 → 1.10.38

package/src/_modules/crypto/_collections/crypto.util.ts

@@ -1,17 +1,18 @@
 import * as CryptoJS from 'crypto-js';
 
-import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+import { DyFM_Error, DyFM_Error_Settings } from '../../../_models/control-models/error.control-model';
+
 
 /**
  * Error codes for crypto operations
  */
-export enum CryptoErrorCode {
+/* export enum CryptoErrorCode {
   INVALID_INPUT = 'DyFM-CRY-EA0',
-  DECRYPTION_FAILED = 'DyFM-CRY-DRY',
+  DECRYPTION_FAILED = '',
   ENCRYPTION_FAILED = 'DyFM-CRY-ENF',
   INVALID_KEY = 'DyFM-CRY-IKY',
   INVALID_DATA = 'DyFM-CRY-IDT'
-}
+} */
 
 /**
  * Configuration options for encryption/decryption
@@ -29,11 +30,14 @@ export interface CryptoConfig {
  */
 export class DyFM_Crypto {
   private static readonly DEFAULT_CONFIG: Required<CryptoConfig> = {
-    ivLength: 16,
-    saltLength: 16,
+    ivLength: 16, // 128 bits
+    saltLength: 16, // 128 bits
     keyIterations: 10000,
-    keySize: 256 / 32
+    keySize: 8 // 256 bits (8 * 32)
   };
+  private static readonly defaultErrorUserMsg = 
+    `We encountered an unhandled Authentication Error, ` +
+    `\nplease contact the responsible development team.`;
 
   // Tömör: kb. 60–80 karakteres token, nem 200+
   // Nem szabványos: nehéz visszafejteni
@@ -43,37 +47,42 @@ export class DyFM_Crypto {
    * Validates the input data and key
    * @throws {DyFM_Error} if validation fails
    */
-  private static validateInput<T>(data: T, key: string): void {
-    if (data === undefined || data === null) {
+  private static validateInput(data: any, key: string): void {
+    if (!key || typeof key !== 'string' || key.trim().length === 0) {
       throw new DyFM_Error({
-        message: 'Data is required',
-        error: new Error('Data is required'),
-        errorCode: CryptoErrorCode.INVALID_DATA
+        ...this.getDefaultErrorSettings('validateInput'),
+        errorCode: 'DyFM-CRY-IKY',
+        message: 'Invalid encryption key'
       });
     }
 
-    if (!key || typeof key !== 'string' || key.trim().length === 0) {
+    if (data === undefined || data === null) {
       throw new DyFM_Error({
-        message: 'Valid key is required',
-        error: new Error('Key must be a non-empty string'),
-        errorCode: CryptoErrorCode.INVALID_KEY
+        ...this.getDefaultErrorSettings('validateInput'),
+        errorCode: 'DyFM-CRY-IDT',
+        message: 'Invalid data to encrypt/decrypt'
       });
     }
   }
 
   /**
-   * Generates a secure random padding
-   * @param length Length of the padding in bytes
+   * Generates a deterministic IV based on the input data and key
    */
-  private static generatePadding(length: number): string {
-    return CryptoJS.lib.WordArray.random(length).toString();
+  private static generateIV(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
+    const hash = CryptoJS.SHA256(data + key);
+    return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.ivLength / 4));
+  }
+
+  /**
+   * Generates a deterministic salt based on the input data and key
+   */
+  private static generateSalt(data: string, key: string, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
+    const hash = CryptoJS.SHA256(key + data);
+    return CryptoJS.lib.WordArray.create(hash.words.slice(0, config.saltLength / 4));
   }
 
   /**
    * Derives a key using PBKDF2
-   * @param key The input key
-   * @param salt The salt to use
-   * @param config Configuration options
    */
   private static deriveKey(key: string, salt: CryptoJS.lib.WordArray, config: Required<CryptoConfig>): CryptoJS.lib.WordArray {
     return CryptoJS.PBKDF2(key, salt, {
@@ -84,38 +93,62 @@ export class DyFM_Crypto {
 
   /**
    * Safely serializes data to JSON
-   * @param data The data to serialize
-   * @returns Serialized data as string
    */
   private static safeSerialize<T>(data: T): string {
     try {
       return JSON.stringify(data);
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Failed to serialize data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.INVALID_DATA
+        ...this.getDefaultErrorSettings('safeSerialize', error),
+        errorCode: 'DyFM-CRY-SER',
+        message: 'Failed to serialize data'
       });
     }
   }
 
   /**
    * Safely deserializes JSON data
-   * @param data The JSON string to deserialize
-   * @returns Deserialized data
    */
   private static safeDeserialize<T>(data: string): T {
     try {
-      return JSON.parse(data);
+      let parsed = JSON.parse(data);
+      
+      // Handle double-stringified JSON
+      if (typeof parsed === 'string') {
+        try {
+          parsed = JSON.parse(parsed);
+        } catch {
+          // If second parse fails, return the string as is
+          return parsed as T;
+        }
+      }
+
+      // Handle primitive values
+      if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean') {
+        return parsed as T;
+      }
+
+      return parsed as T;
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Failed to deserialize data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.DECRYPTION_FAILED
+        ...this.getDefaultErrorSettings('safeDeserialize', error),
+        errorCode: 'DyFM-CRY-DES',
+        message: 'Failed to deserialize data'
       });
     }
   }
 
+  /**
+   * Gets default error settings
+   */
+  private static getDefaultErrorSettings(operation: string, error?: any): DyFM_Error_Settings {
+    return {
+      message: `Crypto operation '${operation}' failed`,
+      error: error instanceof Error ? error : new Error(String(error)),
+      errorCode: 'DyFM-CRY-ERR'
+    };
+  }
+
   /**
    * Encrypts data using AES-256-CBC
    * @param data The data to encrypt
@@ -129,20 +162,18 @@ export class DyFM_Crypto {
       this.validateInput(data, key);
       const finalConfig = { ...this.DEFAULT_CONFIG, ...config };
 
-      // Generate random IV and salt
-      const iv = CryptoJS.lib.WordArray.random(finalConfig.ivLength);
-      const salt = CryptoJS.lib.WordArray.random(finalConfig.saltLength);
+      // Convert data to string
+      const dataStr = this.safeSerialize(data);
+
+      // Generate deterministic IV and salt based on data and key
+      const iv = this.generateIV(dataStr, key, finalConfig);
+      const salt = this.generateSalt(dataStr, key, finalConfig);
 
       // Derive key using PBKDF2
       const derivedKey = this.deriveKey(key, salt, finalConfig);
 
-      // Convert data to string and add random padding
-      const dataStr = this.safeSerialize(data);
-      const padding = this.generatePadding(16);
-      const paddedData = padding + dataStr;
-
       // Encrypt the data
-      const encrypted = CryptoJS.AES.encrypt(paddedData, derivedKey, {
+      const encrypted = CryptoJS.AES.encrypt(dataStr, derivedKey, {
         iv: iv,
         mode: CryptoJS.mode.CBC,
         padding: CryptoJS.pad.Pkcs7
@@ -158,9 +189,8 @@ export class DyFM_Crypto {
         .replace(/=+$/, '');
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Error encrypting data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.ENCRYPTION_FAILED
+        ...this.getDefaultErrorSettings('encrypt', error),
+        errorCode: 'DyFM-CRY-ENC',
       });
     }
   }
@@ -186,6 +216,12 @@ export class DyFM_Crypto {
       // Parse the combined data
       const combined = CryptoJS.enc.Base64.parse(base64);
 
+      // Validate minimum length (IV + Salt + minimum ciphertext)
+      const minLength = (finalConfig.ivLength + finalConfig.saltLength + 16) / 4; // 16 bytes minimum for ciphertext
+      if (combined.words.length < minLength) {
+        throw new Error('Invalid encrypted data length');
+      }
+
       // Extract IV, salt, and ciphertext
       const iv = CryptoJS.lib.WordArray.create(combined.words.slice(0, finalConfig.ivLength / 4));
       const salt = CryptoJS.lib.WordArray.create(
@@ -212,15 +248,13 @@ export class DyFM_Crypto {
         }
       );
 
-      // Remove padding and parse JSON
+      // Parse JSON
       const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
-      const jsonStr = decryptedStr.slice(32); // Remove 16-byte padding
-      return this.safeDeserialize<T>(jsonStr);
+      return this.safeDeserialize<T>(decryptedStr);
     } catch (error) {
       throw new DyFM_Error({
-        message: 'Error decrypting data',
-        error: error instanceof Error ? error : new Error(String(error)),
-        errorCode: CryptoErrorCode.DECRYPTION_FAILED
+        ...this.getDefaultErrorSettings('decrypt', error),
+        errorCode: 'DyFM-CRY-DRY',
       });
     }
   }

package/src/_modules/custom-data/_models/cud.data-model.spec.ts

@@ -2,29 +2,29 @@ import { DyFM_CustomData, DyFM_customData_dataParams } from './cud.data-model';
 import { DyFM_DataModel_Params } from '../../../_models/control-models/data-model-params.control-model';
 import { DyFM_Metadata } from '../../../_models/data-models/metadata.data-model';
 
-describe('DyFM_CustomData', () => {
-  it('should create an instance without initial data', () => {
+describe('| DyFM_CustomData', () => {
+  it('| should create an instance without initial data', () => {
     const instance = new DyFM_CustomData();
     expect(instance).toBeTruthy();
     expect(instance.data).toBeUndefined();
   });
 
-  it('should create an instance with initial data', () => {
+  it('| should create an instance with initial data', () => {
     const initialData = { data: 'testData' };
     const instance = new DyFM_CustomData(initialData);
     expect(instance).toBeTruthy();
     expect(instance.data).toEqual('testData');
   });
 
-  it('should assign properties from the set parameter', () => {
+  it('| should assign properties from the set parameter', () => {
     const initialData = { data: 'testData' };
     const instance = new DyFM_CustomData(initialData);
     expect(instance.data).toEqual(initialData.data);
   });
 });
 
-describe('DyFM_customData_dataParams', () => {
-  it('should have correct dataName and properties', () => {
+describe('| DyFM_customData_dataParams', () => {
+  it('| should have correct dataName and properties', () => {
     expect(DyFM_customData_dataParams.dataName).toEqual('custom_data');
     const properties = DyFM_customData_dataParams.properties;
     expect(properties.data.key).toBe('data');
@@ -32,7 +32,7 @@ describe('DyFM_customData_dataParams', () => {
     expect(properties.data.required).toBe(true);
   });
 
-  it('should be an instance of DyFM_DataModel_Params', () => {
+  it('| should be an instance of DyFM_DataModel_Params', () => {
     expect(DyFM_customData_dataParams).toBeInstanceOf(DyFM_DataModel_Params);
   });
 });

package/src/_modules/location/_collections/loc-regions.util.spec.ts

@@ -5,56 +5,56 @@ import { DyFM_CountryISO } from '../_models/loc-country-iso.interface';
 import { DyFM_CountryPhoneCode } from '../_models/loc-country-phone-code.interface';
 import { DyFM_Regions } from './loc-regions.util';
 
-describe('DyFM_Regions', () => {
-  it('should get all country ISOs', () => {
+describe('| DyFM_Regions', () => {
+  it('| should get all country ISOs', () => {
     const countryISOs: DyFM_CountryISO[] = DyFM_Regions.countryISOs;
     expect(countryISOs).toBeDefined();
     expect(countryISOs.length).toBeGreaterThan(0);
   });
 
-  it('should get all phone codes', () => {
+  it('| should get all phone codes', () => {
     const phoneCodes: DyFM_CountryPhoneCode[] = DyFM_Regions.phoneCodes;
     expect(phoneCodes).toBeDefined();
     expect(phoneCodes.length).toBeGreaterThan(0);
   });
 
-  it('should get all divisions', () => {
+  it('| should get all divisions', () => {
     const divisions: DyFM_CountryDivision[] = DyFM_Regions.divisions;
     expect(divisions).toBeDefined();
     expect(divisions.length).toBeGreaterThan(0);
   });
 
-  it('should convert ISO to country ISO', () => {
+  it('| should convert ISO to country ISO', () => {
     const iso2 = 'US';
     const countryISO: DyFM_CountryISO = DyFM_Regions.isoToCountryIso(iso2);
     expect(countryISO).toBeDefined();
     expect(countryISO.iso2).toBe(iso2);
   });
 
-  /* it('should throw error if ISO not found in isoToCountryIso', () => {
+  /* it('| should throw error if ISO not found in isoToCountryIso', () => {
     const iso2 = 'XX';
     expect(() => DyFM_Regions.isoToCountryIso(iso2)).toThrowError(DyFM_Error);
   });
  */
-  it('should convert ISO to region', () => {
+  it('| should convert ISO to region', () => {
     const iso2 = 'US';
     const region: DyFM_Region = DyFM_Regions.isoToRegion(iso2);
     expect(region).toBeDefined();
   });
 
-  /* it('should throw error if ISO not found in isoToRegion', () => {
+  /* it('| should throw error if ISO not found in isoToRegion', () => {
     const iso2 = 'XX';
     expect(() => DyFM_Regions.isoToRegion(iso2)).toThrowError(DyFM_Error);
   }); */
 
-  it('should convert ISO to phone code', () => {
+  it('| should convert ISO to phone code', () => {
     const iso2 = 'US';
     const phoneCode: DyFM_CountryPhoneCode = DyFM_Regions.isoToPhoneCode(iso2);
     expect(phoneCode).toBeDefined();
     expect(phoneCode.iso).toBe(iso2);
   });
 
-  /* it('should throw error if ISO not found in isoToPhoneCode', () => {
+  /* it('| should throw error if ISO not found in isoToPhoneCode', () => {
     const iso2 = 'XX';
     expect(() => DyFM_Regions.isoToPhoneCode(iso2)).toThrowError(DyFM_Error);
   }); */

package/src/_modules/location/_collections/loc.util.spec.ts

@@ -2,9 +2,9 @@
 import { DyFM_LocationCoordinates } from '../_models/loc-coordinates.interface';
 import { DyFM_Location } from './loc.util';
 
-describe('DyFM_Location', () => {
+describe('| DyFM_Location', () => {
 
-  describe('getDistanceInKilometres', () => {
+  describe('| getDistanceInKilometres', () => {
     xit('should calculate the correct distance between two coordinates', () => {
       const from: DyFM_LocationCoordinates = { latitude: 52.5200, longitude: 13.4050 }; // Berlin
       const to: DyFM_LocationCoordinates = { latitude: 48.8566, longitude: 2.3522 }; // Paris
@@ -14,7 +14,7 @@ describe('DyFM_Location', () => {
       expect(distance).toBeCloseTo(878.7, 1); // Approximate distance in km
     });
 
-    it('should return 0 when the coordinates are the same', () => {
+    it('| should return 0 when the coordinates are the same', () => {
       const from: DyFM_LocationCoordinates = { latitude: 52.5200, longitude: 13.4050 };
 
       const distance = DyFM_Location.getDistanceInKilometres(from, from);
@@ -23,8 +23,8 @@ describe('DyFM_Location', () => {
     });
   });
 
-  describe('getLocationDegByKilometers', () => {
-    it('should calculate the correct degree change for latitude', () => {
+  describe('| getLocationDegByKilometers', () => {
+    it('| should calculate the correct degree change for latitude', () => {
       const distanceInKm = 110.574; // 1 degree of latitude
 
       const degreeChange = DyFM_Location.getLocationDegByKilometers('latitude', distanceInKm);
@@ -41,7 +41,7 @@ describe('DyFM_Location', () => {
       expect(degreeChange).toBeCloseTo(1, 5);
     });
 
-    /* it('should throw an error when calculating longitude without latitude', () => {
+    /* it('| should throw an error when calculating longitude without latitude', () => {
       const distanceInKm = 111.320;
 
       expect(() => {

package/src/_modules/pipe/_collections/utils/pip-country-pipe.util.spec.ts

@@ -3,8 +3,8 @@ import { DyFM_country_pipeTransform } from './pip-country-pipe.util';
 import { DyFM_countryISOs } from '../../../location/_collections/loc-country-isos.const';
 import { DyFM_CountryISO } from '../../../location/_models/loc-country-iso.interface';
 
-describe('DyFM_country_pipeTransform', () => {
-  it('should return the country name when a valid ISO code is provided', () => {
+describe('| DyFM_country_pipeTransform', () => {
+  it('| should return the country name when a valid ISO code is provided', () => {
     const validISO: string = DyFM_countryISOs[0].iso2;
     const expectedName: string = DyFM_countryISOs[0].name;
 
@@ -13,7 +13,7 @@ describe('DyFM_country_pipeTransform', () => {
     expect(result).toBe(expectedName);
   });
 
-  it('should return the input ISO code when an invalid ISO code is provided', () => {
+  it('| should return the input ISO code when an invalid ISO code is provided', () => {
     const invalidISO: string = 'ZZ';
 
     const result: string = DyFM_country_pipeTransform(invalidISO);
@@ -21,7 +21,7 @@ describe('DyFM_country_pipeTransform', () => {
     expect(result).toBe(invalidISO);
   });
 
-  it('should return the input ISO code when an empty string is provided', () => {
+  it('| should return the input ISO code when an empty string is provided', () => {
     const emptyISO: string = '';
 
     const result: string = DyFM_country_pipeTransform(emptyISO);
@@ -29,7 +29,7 @@ describe('DyFM_country_pipeTransform', () => {
     expect(result).toBe(emptyISO);
   });
 
-  it('should return the input ISO code when a null value is provided', () => {
+  it('| should return the input ISO code when a null value is provided', () => {
     const nullISO: string = null as unknown as string;
 
     const result: string = DyFM_country_pipeTransform(nullISO);
@@ -37,7 +37,7 @@ describe('DyFM_country_pipeTransform', () => {
     expect(result).toBe(nullISO);
   });
 
-  it('should return the input ISO code when an undefined value is provided', () => {
+  it('| should return the input ISO code when an undefined value is provided', () => {
     const undefinedISO: string = undefined as unknown as string;
 
     const result: string = DyFM_country_pipeTransform(undefinedISO);

package/src/_modules/pipe/_collections/utils/pip-custom-pipe.util.spec.ts

@@ -1,36 +1,36 @@
 
 import { DyFM_custom_pipeTransform } from './pip-custom-pipe.util';
 
-describe('DyFM_custom_pipeTransform', () => {
-  it('should apply the custom transform function to the input value', () => {
+describe('| DyFM_custom_pipeTransform', () => {
+  it('| should apply the custom transform function to the input value', () => {
     const input = 5;
     const transformFunction = (x: number) => x * 2;
     const result = DyFM_custom_pipeTransform(input, transformFunction);
     expect(result).toBe(10);
   });
 
-  it('should handle string transformations correctly', () => {
+  it('| should handle string transformations correctly', () => {
     const input = 'hello';
     const transformFunction = (x: string) => x.toUpperCase();
     const result = DyFM_custom_pipeTransform(input, transformFunction);
     expect(result).toBe('HELLO');
   });
 
-  it('should handle object transformations correctly', () => {
+  it('| should handle object transformations correctly', () => {
     const input = { name: 'Alice', age: 30 };
     const transformFunction = (x: { name: string; age: number }) => ({ ...x, age: x.age + 1 });
     const result = DyFM_custom_pipeTransform(input, transformFunction);
     expect(result).toEqual({ name: 'Alice', age: 31 });
   });
 
-  it('should handle array transformations correctly', () => {
+  it('| should handle array transformations correctly', () => {
     const input = [1, 2, 3];
     const transformFunction = (x: number[]) => x.map(num => num * 2);
     const result = DyFM_custom_pipeTransform(input, transformFunction);
     expect(result).toEqual([2, 4, 6]);
   });
 
-  it('should return undefined if the transform function returns undefined', () => {
+  it('| should return undefined if the transform function returns undefined', () => {
     const input = 'test';
     const transformFunction = (x: string) => undefined;
     const result = DyFM_custom_pipeTransform(input, transformFunction);

package/src/_modules/pipe/_collections/utils/pip-division-pipe.util.spec.ts

@@ -3,7 +3,7 @@ import { DyFM_division_pipeTransform } from './pip-division-pipe.util';
 import { DyFM_CountryDivision } from '../../../location/_models/loc-country-division.interface';
 import { DyFM_countryDivisions } from '../../../location/_collections/loc-country-divisions.const';
 
-describe('DyFM_division_pipeTransform', () => {
+describe('| DyFM_division_pipeTransform', () => {
   const mockCountryDivisions: DyFM_CountryDivision[] = [
     { code: 'CA', iso: 'US', name: 'California' },
     { code: 'TX', iso: 'US', name: 'Texas' },
@@ -14,27 +14,27 @@ describe('DyFM_division_pipeTransform', () => {
     (DyFM_countryDivisions as DyFM_CountryDivision[]) = mockCountryDivisions;
   });
 
-  it('should return the name of the division when a matching division code and country ISO are found', () => {
+  it('| should return the name of the division when a matching division code and country ISO are found', () => {
     const result = DyFM_division_pipeTransform('CA', 'US');
     expect(result).toBe('California');
   });
 
-  it('should return the division code when no matching division is found', () => {
+  it('| should return the division code when no matching division is found', () => {
     const result = DyFM_division_pipeTransform('NY', 'US');
     expect(result).toBe('NY');
   });
 
-  it('should return the division code when the country ISO does not match', () => {
+  it('| should return the division code when the country ISO does not match', () => {
     const result = DyFM_division_pipeTransform('CA', 'CA');
     expect(result).toBe('CA');
   });
 
-  it('should return the division code when the division code is not found', () => {
+  it('| should return the division code when the division code is not found', () => {
     const result = DyFM_division_pipeTransform('BC', 'CA');
     expect(result).toBe('BC');
   });
 
-  it('should handle empty division code and country ISO gracefully', () => {
+  it('| should handle empty division code and country ISO gracefully', () => {
     const result = DyFM_division_pipeTransform('', '');
     expect(result).toBe('');
   });

package/src/_modules/pipe/_collections/utils/pip-list-pipe.util.spec.ts

@@ -1,32 +1,32 @@
 
 import { DyFM_list_pipeTransform } from './pip-list-pipe.util';
 
-describe('DyFM_list_pipeTransform', () => {
-  it('should transform an array of numbers into a comma-separated string with spaces', () => {
+describe('| DyFM_list_pipeTransform', () => {
+  it('| should transform an array of numbers into a comma-separated string with spaces', () => {
     const input: number[] = [1, 2, 3];
     const expectedOutput: string = '1, 2, 3';
     expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
   });
 
-  it('should transform an array of strings into a comma-separated string with spaces', () => {
+  it('| should transform an array of strings into a comma-separated string with spaces', () => {
     const input: string[] = ['apple', 'banana', 'cherry'];
     const expectedOutput: string = 'apple, banana, cherry';
     expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
   });
 
-  it('should return an empty string for an empty array', () => {
+  it('| should return an empty string for an empty array', () => {
     const input: any[] = [];
     const expectedOutput: string = '';
     expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
   });
 
-  it('should handle an array with a single element correctly', () => {
+  it('| should handle an array with a single element correctly', () => {
     const input: number[] = [42];
     const expectedOutput: string = '42';
     expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);
   });
 
-  it('should handle an array with mixed types correctly', () => {
+  it('| should handle an array with mixed types correctly', () => {
     const input: any[] = [1, 'apple', true];
     const expectedOutput: string = '1, apple, true';
     expect(DyFM_list_pipeTransform(input)).toBe(expectedOutput);

package/src/_modules/pipe/_collections/utils/pip-multi-pipe-pipe.util.spec.ts

@@ -5,33 +5,33 @@ import {
 import { DyFM_MultiPipe_Setting } from '../../_models/pip-multi-pipe-settings.type';
 import { DyFM_multiPipe_pipeTransform, DyFM_multiPipeAngularPipes } from './pip-multi-pipe-pipe.util';
 
-describe('DyFM_multiPipe_pipeTransform', () => {
-  it('should return the original value if no pipes are provided', () => {
+describe('| DyFM_multiPipe_pipeTransform', () => {
+  it('| should return the original value if no pipes are provided', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [];
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
   });
 
-  /* it('should return the original value if pipe has more than one key', () => {
+  /* it('| should return the original value if pipe has more than one key', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ pipe1: [], pipe2: [] }];
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
   });
 
-  it('should return the original value if pipe is not available', () => {
+  it('| should return the original value if pipe is not available', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ unknownPipe: [] }];
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
   });
 
-  it('should transform value using a known pipe without arguments', () => {
+  it('| should transform value using a known pipe without arguments', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
     DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown) => 'transformed';
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('transformed');
   });
 
-  it('should transform value using a known pipe with arguments', () => {
+  it('| should transform value using a known pipe with arguments', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: ['arg1'] }];
     DyFM_pipeTransforms[DyFM_Pipe.currency] = (val: unknown, arg: string) => `transformed with ${arg}`;
@@ -44,14 +44,14 @@ describe('DyFM_multiPipe_pipeTransform', () => {
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe(value);
   });
 
-  it('should transform value using a defined Angular pipe', () => {
+  it('| should transform value using a defined Angular pipe', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_AngularMultiPipeAvailable.currency]: ['arg1'] }];
     DyFM_multiPipeAngularPipes[DyFM_AngularMultiPipeAvailable.currency] = (val: string, arg: string) => `angular transformed with ${arg}`;
     expect(DyFM_multiPipe_pipeTransform(value, pipes)).toBe('angular transformed with arg1');
   });
 
-  /* it('should handle errors gracefully and return the original value', () => {
+  /* it('| should handle errors gracefully and return the original value', () => {
     const value = 'test';
     const pipes: DyFM_MultiPipe_Setting[] = [{ [DyFM_Pipe.currency]: [] }];
     DyFM_pipeTransforms[DyFM_Pipe.currency] = () => { throw new Error('Test error'); };