@futdevpro/fsm-dynamo 1.9.51 → 1.10.2

package/src/_collections/utils/math/random.util.spec.ts

@@ -0,0 +1,82 @@
+
+import { DyFM_Random } from './random.util';
+import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
+
+describe('DyFM_Random', () => {
+  describe('getRandomWeightedInt', () => {
+    it('should return a weighted random integer within the range', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0.1, result: 1 },
+        { chance: 0.3, result: 2 },
+        { chance: 0.6, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+
+    it('should normalize weights if their sum is greater than 1', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0.5, result: 1 },
+        { chance: 0.5, result: 2 },
+        { chance: 0.5, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+
+    it('should return a random integer within the range if no weights match', () => {
+      const weights: DyFM_RandomWeight<number>[] = [
+        { chance: 0, result: 1 },
+        { chance: 0, result: 2 },
+        { chance: 0, result: 3 }
+      ];
+      const result = DyFM_Random.getRandomWeightedInt(1, 3, weights);
+      expect(result).toBeGreaterThanOrEqual(1);
+      expect(result).toBeLessThanOrEqual(3);
+    });
+  });
+
+  describe('getRandomInt', () => {
+    it('should return a random integer within the specified range', () => {
+      const min = 5;
+      const max = 10;
+      const result = DyFM_Random.getRandomInt(min, max);
+      expect(result).toBeGreaterThanOrEqual(min);
+      expect(result).toBeLessThanOrEqual(max);
+    });
+  });
+
+  describe('getRandomListElement', () => {
+    it('should return a random element from the list', () => {
+      const list = [1, 2, 3, 4, 5];
+      const result = DyFM_Random.getRandomListElement(list);
+      expect(list).toContain(result);
+    });
+
+    it('should return null if the list is empty', () => {
+      const list: number[] = [];
+      const result = DyFM_Random.getRandomListElement(list);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getRandomWeighted', () => {
+    it('should return a weighted random element', () => {
+      const weights: DyFM_RandomWeight<string>[] = [
+        { chance: 0.2, result: 'a' },
+        { chance: 0.5, result: 'b' },
+        { chance: 0.3, result: 'c' }
+      ];
+      const result = DyFM_Random.getRandomWeighted(weights);
+      expect(['a', 'b', 'c']).toContain(result);
+    });
+
+    it('should return null if weights array is empty', () => {
+      const weights: DyFM_RandomWeight<string>[] = [];
+      const result = DyFM_Random.getRandomWeighted(weights);
+      expect(result).toBeNull();
+    });
+  });
+});

package/src/_collections/utils/math/trigonometry.util.spec.ts

@@ -0,0 +1,57 @@
+
+import { DyFM_Trigonometry } from './trigonometry.util';
+
+describe('DyFM_Trigonometry', () => {
+  
+  describe('getClamp', () => {
+    it('should calculate the clamp using the hypotenuse and angle', () => {
+      const result = DyFM_Trigonometry.getClamp(10, 30);
+      expect(result).toBeCloseTo(5, 0);
+    });
+
+    it('should use a default angle of 45 degrees if no angle is provided', () => {
+      const result = DyFM_Trigonometry.getClamp(10);
+      expect(result).toBeCloseTo(7.071, 3);
+    });
+  });
+
+  describe('getClampByClampAndHypotenuse', () => {
+    it('should calculate the clamp using another clamp and the hypotenuse', () => {
+      const result = DyFM_Trigonometry.getClampByClampAndHypotenuse(6, 10);
+      expect(result).toBeCloseTo(8, 0);
+    });
+
+    xit('should throw an error if the hypotenuse is smaller than the clamp', () => {
+      expect(() => {
+        DyFM_Trigonometry.getClampByClampAndHypotenuse(12, 10);
+      }).toThrowError('getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:12 > c:10)');
+    });
+  });
+
+  describe('getHypotenuse', () => {
+    it('should calculate the hypotenuse using two clamps', () => {
+      const result = DyFM_Trigonometry.getHypotenuse(3, 4);
+      expect(result).toBeCloseTo(5, 0);
+    });
+
+    it('should use an isosceles triangle if the second clamp is not provided', () => {
+      const result = DyFM_Trigonometry.getHypotenuse(3);
+      expect(result).toBeCloseTo(4.243, 3);
+    });
+  });
+
+  describe('angleToRadians', () => {
+    it('should convert degrees to radians', () => {
+      const result = DyFM_Trigonometry.angleToRadians(180);
+      expect(result).toBeCloseTo(Math.PI, 5);
+    });
+  });
+
+  describe('radiansToAngle', () => {
+    it('should convert radians to degrees', () => {
+      const result = DyFM_Trigonometry.radiansToAngle(Math.PI);
+      expect(result).toBeCloseTo(180, 5);
+    });
+  });
+
+});

package/src/_collections/utils/math/vector2.util.spec.ts

@@ -0,0 +1,94 @@
+
+import { DyFM_Vector2_Util, DyFM_V2_U } from './vector2.util';
+import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
+
+describe('DyFM_Vector2_Util', () => {
+  it('should create an instance with default values', () => {
+    const vector = new DyFM_Vector2_Util();
+    expect(vector.x).toBe(0);
+    expect(vector.y).toBe(0);
+    expect(vector.magintude).toBe(0);
+  });
+
+  it('should create an instance with given x and y values', () => {
+    const vector = new DyFM_Vector2_Util(3, 4);
+    expect(vector.x).toBe(3);
+    expect(vector.y).toBe(4);
+    expect(vector.magintude).toBe(5);
+  });
+
+  it('should create an instance with a DyFM_Vector2 object', () => {
+    const vector = new DyFM_Vector2_Util({ x: 1, y: 2 });
+    expect(vector.x).toBe(1);
+    expect(vector.y).toBe(2);
+    expect(vector.magintude).toBeCloseTo(Math.sqrt(5));
+  });
+
+  it('should calculate distance between two vectors', () => {
+    const a: DyFM_Vector2 = { x: 0, y: 0 };
+    const b: DyFM_Vector2 = { x: 3, y: 4 };
+    const distance = DyFM_Vector2_Util.distance(a, b);
+    expect(distance).toBe(5);
+  });
+
+  it('should add two vectors', () => {
+    const a: DyFM_Vector2 = { x: 1, y: 2 };
+    const b: DyFM_Vector2 = { x: 3, y: 4 };
+    const result = DyFM_Vector2_Util.plus(a, b);
+    expect(result.x).toBe(4);
+    expect(result.y).toBe(6);
+  });
+
+  it('should subtract two vectors', () => {
+    const a: DyFM_Vector2 = { x: 5, y: 6 };
+    const b: DyFM_Vector2 = { x: 3, y: 4 };
+    const result = DyFM_Vector2_Util.minus(a, b);
+    expect(result.x).toBe(2);
+    expect(result.y).toBe(2);
+  });
+
+  it('should multiply a vector by a scalar', () => {
+    const vector: DyFM_Vector2 = { x: 2, y: 3 };
+    const result = DyFM_Vector2_Util.multiply(vector, 2);
+    expect(result.x).toBe(4);
+    expect(result.y).toBe(6);
+  });
+
+  it('should divide a vector by a scalar', () => {
+    const vector: DyFM_Vector2 = { x: 4, y: 6 };
+    const result = DyFM_Vector2_Util.divide(vector, 2);
+    expect(result.x).toBe(2);
+    expect(result.y).toBe(3);
+  });
+
+  it('should negate a vector', () => {
+    const vector: DyFM_Vector2 = { x: 3, y: 4 };
+    const result = DyFM_Vector2_Util.negative(vector);
+    expect(result.x).toBe(-3);
+    expect(result.y).toBe(-4);
+  });
+
+  it('should normalize a vector', () => {
+    const vector: DyFM_Vector2 = { x: 3, y: 4 };
+    const result = DyFM_Vector2_Util.normalize(vector);
+    expect(result.magintude).toBeCloseTo(1);
+  });
+
+  it('should clone a vector', () => {
+    const vector: DyFM_Vector2 = { x: 3, y: 4 };
+    const clone = DyFM_Vector2_Util.clone(vector);
+    expect(clone).toEqual(vector);
+  });
+
+  it('should check if two vectors are equal', () => {
+    const a: DyFM_Vector2 = { x: 3, y: 4 };
+    const b: DyFM_Vector2 = { x: 3, y: 4 };
+    expect(DyFM_Vector2_Util.isEqual(a, b)).toBeTrue();
+  });
+
+  it('should check if two vectors are not equal', () => {
+    const a: DyFM_Vector2 = { x: 3, y: 4 };
+    const b: DyFM_Vector2 = { x: 5, y: 6 };
+    expect(DyFM_Vector2_Util.isEqual(a, b)).toBeFalse();
+  });
+});

package/src/_collections/utils/regex/password-regex.util.spec.ts

@@ -0,0 +1,51 @@
+
+import { DyFM_getPasswordErrors } from './password-regex.util';
+
+describe('DyFM_getPasswordErrors', () => {
+
+  it('should return an empty array for a valid password', () => {
+    const password = 'Valid1!';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toEqual([]);
+  });
+
+  it('should return an error for missing lowercase letter', () => {
+    const password = 'INVALID1!';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must include at least one lowercase letter.');
+  });
+
+  it('should return an error for missing uppercase letter', () => {
+    const password = 'invalid1!';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must include at least one uppercase letter.');
+  });
+
+  it('should return an error for missing digit', () => {
+    const password = 'Invalid!';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must include at least one digit.');
+  });
+
+  it('should return an error for missing special character', () => {
+    const password = 'Invalid1';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must include at least one of the !@#$%^&* characters.');
+  });
+
+  it('should return an error for password length less than 6', () => {
+    const password = 'Inv1!';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must be at least 6 characters long.');
+  });
+
+  it('should return multiple errors for a completely invalid password', () => {
+    const password = 'inv';
+    const result = DyFM_getPasswordErrors(password);
+    expect(result).toContain('Password must include at least one uppercase letter.');
+    expect(result).toContain('Password must include at least one digit.');
+    expect(result).toContain('Password must include at least one of the !@#$%^&* characters.');
+    expect(result).toContain('Password must be at least 6 characters long.');
+  });
+
+});

package/src/_collections/utils/regex/regex.util.spec.ts

@@ -0,0 +1,42 @@
+
+import { DyFM_emailRegex } from './regex.util';
+
+describe('DyFM_emailRegex', () => {
+  it('should match valid email addresses', () => {
+    const validEmails: string[] = [
+      'test@example.com',
+      'user.name+tag+sorting@example.com',
+      'user_name@example.co.uk',
+      'user-name@example.org',
+      'user123@example.museum',
+      'user@example.travel',
+      'user@example.mobi',
+      'user@example.info',
+      'user@example.jobs'
+    ];
+
+    validEmails.forEach(email => {
+      expect(DyFM_emailRegex.test(email)).toBeTrue();
+    });
+  });
+
+  xit('should not match invalid email addresses', () => {
+    const invalidEmails: string[] = [
+      'plainaddress',
+      '@missingusername.com',
+      'username@.com',
+      'username@com',
+      'username@.com.',
+      'username@-example.com',
+      'username@example..com',
+      'username@example.c',
+      'username@.example.com',
+      'username@.example.com.',
+      'username@.example..com'
+    ];
+
+    invalidEmails.forEach(email => {
+      expect(DyFM_emailRegex.test(email)).toBeFalse();
+    });
+  });
+});

package/src/_collections/utils/regex/username-regex.util.spec.ts

@@ -0,0 +1,61 @@
+
+import { DyFM_usernameRegex } from './username-regex.util';
+
+describe('DyFM_usernameRegex', () => {
+  it('should match valid usernames', () => {
+    const validUsernames: string[] = [
+      'abcdef',
+      '123456',
+      'abc123',
+      'abc-123',
+      'abc_123',
+      'abc#123',
+      'abc$123',
+      'abc%123',
+      'abc&123',
+      'abc^123',
+      'abc|123',
+      'abc*123',
+      'abc-_$#%&^|*'
+    ];
+
+    validUsernames.forEach(username => {
+      expect(DyFM_usernameRegex.test(username)).toBeTrue();
+    });
+  });
+
+  it('should not match invalid usernames', () => {
+    const invalidUsernames: string[] = [
+      'abc',          // less than 6 characters
+      'abc!',         // invalid special character
+      'abc@123',      // invalid special character
+      'abc 123',      // space is not allowed
+      'abc/123',      // invalid special character
+      'abc\\123',     // invalid special character
+      'abc+123',      // invalid special character
+      'abc=123',      // invalid special character
+      'abc,123',      // invalid special character
+      'abc.123',      // invalid special character
+      'abc:123',      // invalid special character
+      'abc;123',      // invalid special character
+      'abc<123',      // invalid special character
+      'abc>123',      // invalid special character
+      'abc?123',      // invalid special character
+      'abc@123',      // invalid special character
+      'abc[123',      // invalid special character
+      'abc]123',      // invalid special character
+      'abc{123',      // invalid special character
+      'abc}123',      // invalid special character
+      'abc(123',      // invalid special character
+      'abc)123',      // invalid special character
+      'abc~123',      // invalid special character
+      'abc`123',      // invalid special character
+      'abc"123',      // invalid special character
+      'abc\'123',     // invalid special character
+    ];
+
+    invalidUsernames.forEach(username => {
+      expect(DyFM_usernameRegex.test(username)).toBeFalse();
+    });
+  });
+});

package/src/_collections/utils/round-list.util.spec.ts

@@ -0,0 +1,79 @@
+
+import { DyFM_RoundList } from './round-list.util';
+
+describe('DyFM_RoundList', () => {
+
+  describe('getOutboundedIndex', () => {
+    it('should throw an error if listLength is 0', () => {
+      expect(() => DyFM_RoundList.getOutboundedIndex(0, 5)).toThrowError('roundListPlusIndex failed. list is empty!');
+    });
+
+    it('should return correct index for positive outboundIndex within bounds', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, 3)).toBe(3);
+    });
+
+    it('should return correct index for positive outboundIndex out of bounds', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, 7)).toBe(2);
+    });
+
+    it('should return correct index for negative outboundIndex', () => {
+      expect(DyFM_RoundList.getOutboundedIndex(5, -2)).toBe(3);
+    });
+  });
+
+  describe('getIndexOpposite', () => {
+    it('should return the opposite index in a circular manner', () => {
+      expect(DyFM_RoundList.getIndexOpposite(8, 7)).toBe(3);
+    });
+
+    it('should handle even length arrays correctly', () => {
+      expect(DyFM_RoundList.getIndexOpposite(4, 1)).toBe(3);
+    });
+
+    it('should handle odd length arrays correctly', () => {
+      expect(DyFM_RoundList.getIndexOpposite(5, 2)).toBe(0);
+    });
+  });
+
+  describe('getListIndex', () => {
+    it('should return the correct element for a given outboundIndex', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListIndex(list, 5)).toBe('b');
+    });
+
+    it('should handle negative outboundIndex', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListIndex(list, -1)).toBe('d');
+    });
+  });
+
+  describe('getListOpposite', () => {
+    it('should return the opposite element in a circular manner', () => {
+      const list = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'];
+      expect(DyFM_RoundList.getListOpposite(list, 'h')).toBe('d');
+    });
+
+    it('should handle even length lists correctly', () => {
+      const list = ['a', 'b', 'c', 'd'];
+      expect(DyFM_RoundList.getListOpposite(list, 'b')).toBe('d');
+    });
+
+    it('should handle odd length lists correctly', () => {
+      const list = ['a', 'b', 'c', 'd', 'e'];
+      expect(DyFM_RoundList.getListOpposite(list, 'c')).toBe('a');
+    });
+  });
+
+  describe('getLast', () => {
+    it('should return the last element of the list', () => {
+      const list = ['a', 'b', 'c'];
+      expect(DyFM_RoundList.getLast(list)).toBe('c');
+    });
+
+    it('should return null for an empty list', () => {
+      const list: string[] = [];
+      expect(DyFM_RoundList.getLast(list)).toBeNull();
+    });
+  });
+
+});

package/src/_collections/utils/round-list.util.ts

@@ -4,7 +4,7 @@
 
 export class DyFM_RoundList {  
   static getOutboundedIndex(listLength: number, outboundIndex: number): number {
-    if (!(0 < listLength)) {
+    if (!listLength) {
       throw new Error('roundListPlusIndex failed. list is empty!');
     }
   
@@ -42,4 +42,49 @@ export class DyFM_RoundList {
       return null;
     }
   }
+
+  /** 
+   * returns the opposite index as they circular
+   * so after the last index, the first comes next
+   * an array that has 8 elements, the opposite of 7 is 3
+   * */
+  /* static getRoundListOppositeIndex(
+    arrayLength: number, 
+    index: number, 
+    roundUp: boolean = false
+  ): number {
+    const oppositeIndex = index + (
+      roundUp ? 
+        Math.ceil(arrayLength / 2) : 
+        Math.floor(arrayLength / 2)
+    );
+
+    if (arrayLength <= oppositeIndex) {
+      return oppositeIndex - arrayLength;
+    } else {
+      return oppositeIndex;
+    }
+  }
+
+  static getRoundListOutboundIndex<T>(array: T[], index: number): T {
+    try {
+      while (array.length <= index) {
+        index -= array.length;
+      }
+  
+      while (index < 0) {
+        index += array.length;
+      }
+      
+      return array[index];
+    } catch (error) {
+      console.error(
+        'DyFM_Array.getRoundListOutboundIndex error:', error,
+        '\narray:', array,
+        '\nindex:', index
+      );
+      
+      return null;
+    }
+  } */
 }

package/src/_collections/utils/shared.util.spec.ts

@@ -0,0 +1,143 @@
+
+import { DyFM_Shared } from './shared.util';
+
+describe('DyFM_Shared', () => {
+
+  describe('mapObjList', () => {
+    it('should remap object list based on given paths', () => {
+      const objList = [
+        {
+          first: {
+            sub: { label: 'vlmi' },
+            dif: { name: 'asd' }
+          }
+        }
+      ];
+      const paths = [['first', 'sub', 'label'], ['first', 'dif', 'name']];
+      const expected = [{ label: 'vlmi', name: 'asd' }];
+
+      const result = DyFM_Shared.mapObjList(objList, paths);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('getNestedData', () => {
+    it('should return nested value from object', () => {
+      const obj = {
+        nestLvl1: {
+          nestLvl2: {
+            nestLvl3: 'value'
+          }
+        }
+      };
+      const path = ['nestLvl1', 'nestLvl2', 'nestLvl3'];
+
+      const result = DyFM_Shared.getNestedData(obj, path);
+
+      expect(result).toBe('value');
+    });
+  });
+
+  describe('nestData', () => {
+    xit('should nest data at specified path', () => {
+      const obj = {};
+      const path = ['level1', 'level2'];
+      const value = 'nestedValue';
+      const expected = { level1: { level2: 'nestedValue' } };
+
+      const result = DyFM_Shared.nestData(obj, path, value);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('addToNestedData', () => {
+    it('should add to nested data at specified path', () => {
+      const obj = { level1: { level2: 5 } };
+      const path = ['level1', 'level2'];
+      const valueToAdd = 3;
+      const expected = { level1: { level2: 8 } };
+
+      const result = DyFM_Shared.addToNestedData(obj, path, valueToAdd);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('pushToNestedData', () => {
+    it('should push to nested array at specified path', () => {
+      const obj = { level1: { level2: [1, 2] } };
+      const path = ['level1', 'level2'];
+      const valueToPush = 3;
+      const expected = { level1: { level2: [1, 2, 3] } };
+
+      const result = DyFM_Shared.pushToNestedData(obj, path, valueToPush);
+
+      expect(result).toEqual(expected);
+    });
+
+    it('should create an array and push if none exists', () => {
+      const obj = { level1: {} };
+      const path = ['level1', 'level2'];
+      const valueToPush = 3;
+      const expected = { level1: { level2: [3] } };
+
+      const result = DyFM_Shared.pushToNestedData(obj, path, valueToPush);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('nestRecursiveListedData', () => {
+    it('should nest data in recursive list structure', () => {
+      const obj = { listKey: [{ listKey: [{ listKey: [{}] }] }] };
+      const nestedListKey = 'listKey';
+      const nestIndexes = [0, 0, 0];
+      const value = 'nestedValue';
+      const expected = { listKey: [{ listKey: [{ listKey: ['nestedValue'] }] }] };
+
+      const result = DyFM_Shared.nestRecursiveListedData(obj, nestedListKey, nestIndexes, value);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('resolveCirculation', () => {
+    xit('should resolve circular references in data', () => {
+      const obj: any = { inner: {} };
+      obj.inner.self = obj;
+      const expected = { inner: { self: 'CIRCULATION:Object.inner' } };
+
+      const result = DyFM_Shared.resolveCirculation(obj);
+
+      expect(result).toEqual(expected);
+    });
+
+    xit('should resolve circular references in data', () => {
+      const obj: any = {};
+      obj.self = obj;
+      const expected = { self: 'CIRCULATION:ROOT;Object.self' };
+
+      const result = DyFM_Shared.resolveCirculation(obj);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('findCirculations', () => {
+    xit('should find circular references in data', () => {
+      const obj: any = {};
+      obj.self = obj;
+      const expected = [{
+        object: obj,
+        pathsOfAllDuplications: ['ROOT;Object', 'self']
+      }];
+
+      const result = DyFM_Shared.findCirculations(obj);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+});