@futdevpro/fsm-dynamo 1.16.7 → 1.16.9

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

@@ -1,139 +1,139 @@
-
-
-import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
-import { DyFM_Log } from '../log.util';
-
-/**
- * this class is a collection of static methods for random operations
- */
-export class DyFM_Random {
-  /**
-   * returns a random weighted integer between the min and max
-   * 
-   * @example
-   * ```ts
-   * const randomWeightedInt = DyFM_Random.getRandomWeightedInt(1, 10, [
-   *   { chance: 0.1, result: 1 },
-   *   { chance: 0.3, result: 2 },
-   *   { chance: 0.6, result: 3 }
-   * ]);
-   * console.log(randomWeightedInt);
-   * ```
-   */
-  static getRandomWeightedInt(
-    min: number, 
-    max: number, 
-    weights: DyFM_RandomWeight<number>[]
-  ): number {
-    weights = weights.sort((a, b): number => b.chance - a.chance);
-    let weightChanceSum = 0;
-
-    weights.forEach((weight): void => { weightChanceSum += weight.chance; });
-
-    if (1 < weightChanceSum) {
-      weights.forEach((weights): void => { weights.chance = weights.chance / weightChanceSum; });
-    }
-  
-    const randomChance: number = Math.random();
-    let result: number | undefined;
-    let chancer = 0;
-
-    for (let i = 0; i < weights.length && result === undefined; i++) {
-      chancer += weights[i].chance;
-
-      if (randomChance < chancer) {
-        result = weights[i].result;
-      }
-    }
-  
-    if (result !== undefined) {
-      return result;
-    } else {
-      return this.getRandomInt(min, max);
-    }
-  }
-  
-  /**
-   * returns a random integer between the min and max
-   * @param min - the minimum value (inclusive)
-   * @param max - the maximum value (inclusive)
-   * @returns a random integer between the min and max
-   * 
-   * @example
-   * ```ts
-   * const randomInt = DyFM_Random.getRandomInt(1, 10);
-   * console.log(randomInt); // 5
-   * ```
-   */
-  static getRandomInt(min: number, max: number): number {
-    return min + Math.round((max - min) * Math.random());
-  }
-  
-  /**
-   * returns null if list is empty
-   * @param list 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const randomListElement = DyFM_Random.getRandomListElement([1, 2, 3, 4, 5]);
-   * console.log(randomListElement); // 3
-   * ```
-   */
-  static getRandomListElement<T>(list: T[]): T | null {
-    if (0 < list.length) {
-      return list[this.getRandomInt(0, list.length - 1)];
-    } else {
-      return null;
-    }
-  }
-  
-  /**
-   * returns a random weighted element from the list
-   * (returns null if list is empty)
-   * @param weights 
-   * @returns 
-   * 
-   * @example
-   * ```ts
-   * const randomWeightedElement = DyFM_Random.getRandomWeighted([
-   *   { chance: 0.1, result: '1' },
-   *   { chance: 0.3, result: '2' },
-   *   { chance: 0.6, result: '3' }
-   * ]);
-   */
-  static getRandomWeighted<T>(weights: DyFM_RandomWeight<T>[]): T | null {
-    if (!weights?.length) {
-      return null;
-    }
-  
-    weights = weights.sort((a, b): number => b.chance - a.chance);
-    let weightChanceSum = 0;
-
-    weights.forEach((weight): void => { 
-      weightChanceSum += weight.chance; 
-    });
-    weights.forEach((weights): void => { 
-      weights.chance = weights.chance / weightChanceSum; 
-    });
-  
-    const randomChance: number = Math.random();
-    let result: T | undefined;
-    let chancer = 0;
-
-    for (let i = 0; i < weights.length && result === undefined; i++) {
-      chancer += weights[i].chance;
-
-      if (randomChance < chancer) {
-        result = weights[i].result;
-      }
-    }
-
-    if (result === undefined) {
-      DyFM_Log.error('DyFM_Random failed to get a random weighted element from the list');
-      return null;
-    }
-  
-    return result;
-  }
-}
+
+
+import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
+import { DyFM_Log } from '../log.util';
+
+/**
+ * this class is a collection of static methods for random operations
+ */
+export class DyFM_Random {
+  /**
+   * returns a random weighted integer between the min and max
+   * 
+   * @example
+   * ```ts
+   * const randomWeightedInt = DyFM_Random.getRandomWeightedInt(1, 10, [
+   *   { chance: 0.1, result: 1 },
+   *   { chance: 0.3, result: 2 },
+   *   { chance: 0.6, result: 3 }
+   * ]);
+   * console.log(randomWeightedInt);
+   * ```
+   */
+  static getRandomWeightedInt(
+    min: number, 
+    max: number, 
+    weights: DyFM_RandomWeight<number>[]
+  ): number {
+    weights = weights.sort((a, b): number => b.chance - a.chance);
+    let weightChanceSum = 0;
+
+    weights.forEach((weight): void => { weightChanceSum += weight.chance; });
+
+    if (1 < weightChanceSum) {
+      weights.forEach((weights): void => { weights.chance = weights.chance / weightChanceSum; });
+    }
+  
+    const randomChance: number = Math.random();
+    let result: number | undefined;
+    let chancer = 0;
+
+    for (let i = 0; i < weights.length && result === undefined; i++) {
+      chancer += weights[i].chance;
+
+      if (randomChance < chancer) {
+        result = weights[i].result;
+      }
+    }
+  
+    if (result !== undefined) {
+      return result;
+    } else {
+      return this.getRandomInt(min, max);
+    }
+  }
+  
+  /**
+   * returns a random integer between the min and max
+   * @param min - the minimum value (inclusive)
+   * @param max - the maximum value (inclusive)
+   * @returns a random integer between the min and max
+   * 
+   * @example
+   * ```ts
+   * const randomInt = DyFM_Random.getRandomInt(1, 10);
+   * console.log(randomInt); // 5
+   * ```
+   */
+  static getRandomInt(min: number, max: number): number {
+    return min + Math.round((max - min) * Math.random());
+  }
+  
+  /**
+   * returns null if list is empty
+   * @param list 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const randomListElement = DyFM_Random.getRandomListElement([1, 2, 3, 4, 5]);
+   * console.log(randomListElement); // 3
+   * ```
+   */
+  static getRandomListElement<T>(list: T[]): T | null {
+    if (0 < list.length) {
+      return list[this.getRandomInt(0, list.length - 1)];
+    } else {
+      return null;
+    }
+  }
+  
+  /**
+   * returns a random weighted element from the list
+   * (returns null if list is empty)
+   * @param weights 
+   * @returns 
+   * 
+   * @example
+   * ```ts
+   * const randomWeightedElement = DyFM_Random.getRandomWeighted([
+   *   { chance: 0.1, result: '1' },
+   *   { chance: 0.3, result: '2' },
+   *   { chance: 0.6, result: '3' }
+   * ]);
+   */
+  static getRandomWeighted<T>(weights: DyFM_RandomWeight<T>[]): T | null {
+    if (!weights?.length) {
+      return null;
+    }
+  
+    weights = weights.sort((a, b): number => b.chance - a.chance);
+    let weightChanceSum = 0;
+
+    weights.forEach((weight): void => { 
+      weightChanceSum += weight.chance; 
+    });
+    weights.forEach((weights): void => { 
+      weights.chance = weights.chance / weightChanceSum; 
+    });
+  
+    const randomChance: number = Math.random();
+    let result: T | undefined;
+    let chancer = 0;
+
+    for (let i = 0; i < weights.length && result === undefined; i++) {
+      chancer += weights[i].chance;
+
+      if (randomChance < chancer) {
+        result = weights[i].result;
+      }
+    }
+
+    if (result === undefined) {
+      DyFM_Log.error('DyFM_Random failed to get a random weighted element from the list');
+      return null;
+    }
+  
+    return result;
+  }
+}

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

@@ -1,57 +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);
-    });
-  });
-
-});
+
+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/trigonometry.util.ts

@@ -1,102 +1,102 @@
-
-export type DyFM_Trig = DyFM_Trigonometry;
-export type DyFM_Δ = DyFM_Trigonometry;
-export class DyFM_Trigonometry {
-  
-  /**
-   * Befogó
-   * a Befogó mérete az átfogó, és a befogóval szemközti szög alapján
-   * a szemközti szög értéke opcionális 
-   * (amennyiben nem adjuk meg, 45 fokos szöggel számolunk)
-   * @param c átfogó
-   * @param angle a befogó oldallal szemközti szög (fokban)
-   * @returns befogó
-   * 
-   * @example
-   * ```ts
-   * const clamp = DyFM_Trigonometry.getClamp(10, 30);
-   * console.log(clamp); // 5
-   * ```
-   */
-  static getClamp(c: number, angle?: number): number {
-    angle = angle !== undefined ? angle : 45;
-
-    return Math.sin(this.angleToRadians(angle)) * c;
-  }
-
-  /**
-   * Befogó
-   * a Befogó mérete az átfogó és a másik befogó alapján
-   * @param a befogó
-   * @param c átfogó
-   * @returns befogó
-   * 
-   * @example
-   * ```ts
-   * const clamp = DyFM_Trigonometry.getClampByClampAndHypotenuse(6, 10);
-   * console.log(clamp); // 8
-   * ```
-   */
-  static getClampByClampAndHypotenuse(a: number, c: number): number {
-    if (a > c) {
-
-      throw { 
-        errorMessage: 
-          `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` 
-      };
-    }
-
-    return Math.sqrt((c * c) - (a * a));
-  }
-
-  /**
-   * Átfogó
-   * az Átfogó mérete a befogók alapján
-   * a második befogó értéke opcionális 
-   * (amennyiben nem adjuk meg, egyenlő szárú háromszöggel számolunk)
-   * @param a egyik befogó
-   * @param b másik befogó
-   * @returns átfogó
-   * 
-   * @example
-   * ```ts
-   * const hypotenuse = DyFM_Trigonometry.getHypotenuse(3, 4);
-   * console.log(hypotenuse); // 5
-   * ```
-   */
-  static getHypotenuse(a: number, b?: number): number {
-    b = b !== undefined ? b : a;
-    
-    return Math.sqrt((a * a) + (b * b));
-  }
-
-  /**
-   * Szög fokmértéket átalakítja radiánsra
-   * @param angle szög fok
-   * @returns szög radiáns
-   * 
-   * @example
-   * ```ts
-   * const radians = DyFM_Trigonometry.angleToRadians(180);
-   * console.log(radians); // 3.141592653589793
-   * ```
-   */
-  static angleToRadians(angle: number): number {
-    return angle * Math.PI / 180;
-  }
-
-  /**
-   * Szög radiáns mértéket átalakítja fokra
-   * @param radians szög radiáns
-   * @returns szög fok
-   * 
-   * @example
-   * ```ts
-   * const angle = DyFM_Trigonometry.radiansToAngle(3.141592653589793);
-   * console.log(angle); // 180
-   * ```
-   */
-  static radiansToAngle(radians: number): number {
-    return radians / Math.PI * 180;
-  }
-}
+
+export type DyFM_Trig = DyFM_Trigonometry;
+export type DyFM_Δ = DyFM_Trigonometry;
+export class DyFM_Trigonometry {
+  
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó, és a befogóval szemközti szög alapján
+   * a szemközti szög értéke opcionális 
+   * (amennyiben nem adjuk meg, 45 fokos szöggel számolunk)
+   * @param c átfogó
+   * @param angle a befogó oldallal szemközti szög (fokban)
+   * @returns befogó
+   * 
+   * @example
+   * ```ts
+   * const clamp = DyFM_Trigonometry.getClamp(10, 30);
+   * console.log(clamp); // 5
+   * ```
+   */
+  static getClamp(c: number, angle?: number): number {
+    angle = angle !== undefined ? angle : 45;
+
+    return Math.sin(this.angleToRadians(angle)) * c;
+  }
+
+  /**
+   * Befogó
+   * a Befogó mérete az átfogó és a másik befogó alapján
+   * @param a befogó
+   * @param c átfogó
+   * @returns befogó
+   * 
+   * @example
+   * ```ts
+   * const clamp = DyFM_Trigonometry.getClampByClampAndHypotenuse(6, 10);
+   * console.log(clamp); // 8
+   * ```
+   */
+  static getClampByClampAndHypotenuse(a: number, c: number): number {
+    if (a > c) {
+
+      throw { 
+        errorMessage: 
+          `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` 
+      };
+    }
+
+    return Math.sqrt((c * c) - (a * a));
+  }
+
+  /**
+   * Átfogó
+   * az Átfogó mérete a befogók alapján
+   * a második befogó értéke opcionális 
+   * (amennyiben nem adjuk meg, egyenlő szárú háromszöggel számolunk)
+   * @param a egyik befogó
+   * @param b másik befogó
+   * @returns átfogó
+   * 
+   * @example
+   * ```ts
+   * const hypotenuse = DyFM_Trigonometry.getHypotenuse(3, 4);
+   * console.log(hypotenuse); // 5
+   * ```
+   */
+  static getHypotenuse(a: number, b?: number): number {
+    b = b !== undefined ? b : a;
+    
+    return Math.sqrt((a * a) + (b * b));
+  }
+
+  /**
+   * Szög fokmértéket átalakítja radiánsra
+   * @param angle szög fok
+   * @returns szög radiáns
+   * 
+   * @example
+   * ```ts
+   * const radians = DyFM_Trigonometry.angleToRadians(180);
+   * console.log(radians); // 3.141592653589793
+   * ```
+   */
+  static angleToRadians(angle: number): number {
+    return angle * Math.PI / 180;
+  }
+
+  /**
+   * Szög radiáns mértéket átalakítja fokra
+   * @param radians szög radiáns
+   * @returns szög fok
+   * 
+   * @example
+   * ```ts
+   * const angle = DyFM_Trigonometry.radiansToAngle(3.141592653589793);
+   * console.log(angle); // 180
+   * ```
+   */
+  static radiansToAngle(radians: number): number {
+    return radians / Math.PI * 180;
+  }
+}