@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

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

@@ -1,139 +0,0 @@
-
-
-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 +0,0 @@
-
-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 +0,0 @@
-
-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;
-  }
-}

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

@@ -1,94 +0,0 @@
-
-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();
-  });
-});