@futdevpro/fsm-dynamo 1.20.8 → 1.20.10

package/src/_collections/utils/math/box-bounds.spec.ts

@@ -1,74 +0,0 @@
-import { DyFM_BoxBounds_Util } from './box-bounds.util';
-import { DyFM_Vector2_Util } from './vector2.util';
-
-describe('| DyFM_BoxBounds', () => {
-  let boxBounds: DyFM_BoxBounds_Util;
-  const mockPosition = new DyFM_Vector2_Util({ x: 0, y: 0 });
-  const mockSize = new DyFM_Vector2_Util({ x: 10, y: 10 });
-
-  beforeEach(() => {
-    boxBounds = new DyFM_BoxBounds_Util(mockPosition, mockSize);
-  });
-
-  it('| should set position correctly ()', () => {
-    const newPosition = new DyFM_Vector2_Util({ x: 5, y: 5 });
-
-    boxBounds.pos = newPosition;
-    expect(boxBounds.pos).toEqual(newPosition);
-  });
-
-  it('| should get position correctly', () => {
-    const expectedPosition = new DyFM_Vector2_Util({ x: 0, y: 0 });
-
-    expect(boxBounds.pos).toEqual(expectedPosition);
-  });
-
-  it('| should set size correctly', () => {
-    const newSize = new DyFM_Vector2_Util({ x: 20, y: 20 });
-
-    boxBounds.size = newSize;
-    expect(boxBounds.size).toEqual(newSize);
-  });
-
-  it('| should get size correctly', () => {
-    const expectedSize = new DyFM_Vector2_Util({ x: 10, y: 10 });
-
-    expect(boxBounds.size).toEqual(expectedSize);
-  });
-
-  it('| should calculate center correctly', () => {
-    const expectedCenter = new DyFM_Vector2_Util({ x: 5, y: 5 });
-    expect(boxBounds.center).toEqual(expectedCenter);
-  });
-
-  it('| should calculate center margin correctly', () => {
-    const expectedCenterMargin = new DyFM_Vector2_Util({ x: -5, y: -5 });
-    expect(boxBounds.centerMargin).toEqual(expectedCenterMargin);
-  });
-
-  it('| should return true for constructed method', () => {
-    expect(boxBounds.constructed()).toBe(true);
-  });
-
-  it('| should throw error when newValues has undefined position', () => {
-    expect(() => {
-      boxBounds.newValues(undefined as any, { x: 10, y: 10 });
-    }).toThrowError('new position is undefined!');
-  });
-
-  it('| should throw error when newValues has undefined size', () => {
-    expect(() => {
-      boxBounds.newValues({ x: 0, y: 0 }, undefined as any);
-    }).toThrowError('new size is undefined!');
-  });
-
-  it('| should clone and return a new instance', () => {
-    const clonedBoxBounds = boxBounds.clone();
-
-    expect(clonedBoxBounds).toBeInstanceOf(DyFM_BoxBounds_Util);
-    expect(clonedBoxBounds).toEqual(boxBounds);
-  });
-  
-  
-
-});

package/src/_collections/utils/math/box-bounds.util.ts

@@ -1,183 +0,0 @@
-
-
-import { DyFM_BoxBounds } from '../../../_models/interfaces/box-bounds.interface';
-import { DyFM_Vector2 } from '../../../_models/interfaces/vector2.interface';
-import { DyFM_Vector2_Util } from './vector2.util';
-
-/**
- * The main difference between static class functions and instance functions 
- * is that static functions return new BoxBounds, 
- * while instance functions change the current BoxBounds and returns itself.
- * (if this is not true, report it as a bug)
- * 
- * @example
- * ```ts
- * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
- * boxBounds.pos = { x: 5, y: 5 };
- * console.log(boxBounds.pos);
- * ```
- */
-export class DyFM_BoxBounds_Util {
-  private readonly _pos: DyFM_Vector2_Util;
-  /**
-   * setting the position will also recalculate the center and centerMargin
-   */
-  set pos(value: DyFM_Vector2) {
-    this._pos.newValues(value);
-
-    this.calcCenter();
-  }
-  /**
-   * getting the position will return the position as a DyFM_Vector2_Util
-   */
-  get pos(): DyFM_Vector2_Util { 
-    return this._pos;
-  }
-
-  private readonly _size: DyFM_Vector2_Util;
-  /**
-   * setting the size will also recalculate the center and centerMargin
-   */
-  set size(value: DyFM_Vector2) {
-    this._size.newValues(value);
-    
-    this.calcCenter();
-  }
-  /**
-   * getting the size will return the size as a DyFM_Vector2_Util
-   */
-  get size(): DyFM_Vector2_Util { 
-    return this._size;
-  }
-
-  private _center!: DyFM_Vector2_Util;
-  /**
-   * getting the center will return the center as a DyFM_Vector2_Util
-   * (this is calculated from the position and size every time they are set)
-   */
-  get center(): DyFM_Vector2_Util {
-    return this._center;
-  }
-
-  private _centerMargin!: DyFM_Vector2_Util;
-  /**
-   * getting the centerMargin will return the centerMargin as a DyFM_Vector2_Util
-   * (this is calculated from the size every time it is set)
-   */
-  get centerMargin(): DyFM_Vector2_Util {
-    return this._centerMargin;
-  }
-
-  constructor(
-    /** top left corner */
-    position?: DyFM_Vector2, 
-    /** height and width */
-    size?: DyFM_Vector2
-  ) {
-    this._pos = new DyFM_Vector2_Util(position);
-    this._size = new DyFM_Vector2_Util(size);
-
-    this.calcCenter();
-  }
-
-  /**
-   * returns true if the box bounds has been constructed
-   */
-  constructed(): boolean { 
-    return true; 
-  }
-
-  /**
-   * sets the position and size of the box bounds
-   * (this will also recalculate the center and centerMargin)
-   * 
-   * @example
-   * ```ts
-   * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
-   * boxBounds.newValues({ x: 5, y: 5 }, { x: 20, y: 20 });
-   * ```
-   */
-  newValues(position: DyFM_Vector2, size: DyFM_Vector2): void {
-    if (position === undefined) {
-      throw new Error('new position is undefined!');
-    }
-
-    if (size === undefined) {
-      throw new Error('new size is undefined!');
-    }
-
-    this._pos.newValues(position);
-    this._size.newValues(size);
-
-    this.calcCenter();
-  }
-
-  /**
-   * returns true if the position is within the box bounds
-   * 
-   * @example
-   * ```ts
-   * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
-   * const position = new DyFM_Vector2({ x: 5, y: 5 });
-   * const isWithinBounds = DyFM_BoxBounds_Util.bounds(boxBounds, position);
-   * console.log(isWithinBounds);
-   * ```
-   */
-  static bounds(box: DyFM_BoxBounds_Util, position: DyFM_Vector2): boolean {
-    return  box.pos.x <= position.x && position.x <= box.pos.x + box.size.x && 
-            box.pos.y <= position.y && position.y <= box.pos.y + box.size.y;
-  }
-  /**
-   * returns true if the position is within the box bounds
-   * 
-   * @example
-   * ```ts
-   * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
-   * const isWithinBounds = boxBounds.bounds(new DyFM_Vector2({ x: 5, y: 5 });
-   * console.log(isWithinBounds);
-   * ```
-   */
-  bounds(position: DyFM_Vector2): boolean {
-    return DyFM_BoxBounds_Util.bounds(this, position);
-  }
-
-  /**
-   * calculates the center and centerMargin of the box bounds
-   * 
-   * only usable inside the class
-   */
-  private calcCenter(): void {
-    const halfSize = DyFM_Vector2_Util.divide(this.size, 2);
-
-    this._center = DyFM_Vector2_Util.plus(this.pos, halfSize);
-    this._centerMargin = DyFM_Vector2_Util.negative(halfSize);
-  }
-
-  /**
-   * returns the box bounds as a DyFM_BoxBounds
-   */
-  get(): DyFM_BoxBounds {
-    return {
-      pos: this._pos.get(),
-      size: this._size.get(),
-      center: this._center.get(),
-      centerMargin: this._centerMargin.get()
-    };
-  }
-  getBoxBounds = this.get;
-  toBoxBounds = this.get;
-
-  /**
-   * returns a new DyFM_BoxBounds_Util with the same position and size
-   * 
-   * @example
-   * ```ts
-   * const boxBounds = new DyFM_BoxBounds_Util({ x: 0, y: 0 }, { x: 10, y: 10 });
-   * const clonedBoxBounds = boxBounds.clone();
-   * ```
-   */
-  clone(): DyFM_BoxBounds_Util {
-    return new DyFM_BoxBounds_Util(this._pos.clone(), this._size.clone());
-  }
-}
-

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

@@ -1,94 +0,0 @@
-
-import { DyFM_Math } from './math.util';
-
-describe('| DyFM_Math', () => {
-
-  describe('| between', () => {
-    it('| should return true if value is between minExclusive and maxExclusive', () => {
-      expect(DyFM_Math.between(5, 1, 10)).toBeTrue();
-    });
-
-    it('| should return false if value is equal to minExclusive', () => {
-      expect(DyFM_Math.between(1, 1, 10)).toBeFalse();
-    });
-
-    it('| should return false if value is equal to maxExclusive', () => {
-      expect(DyFM_Math.between(10, 1, 10)).toBeFalse();
-    });
-
-    it('| should return false if value is outside the range', () => {
-      expect(DyFM_Math.between(0, 1, 10)).toBeFalse();
-      expect(DyFM_Math.between(11, 1, 10)).toBeFalse();
-    });
-  });
-
-  describe('| around', () => {
-    xit('should return true if value is within the range of target', () => {
-      expect(DyFM_Math.around(5, 5, 0)).toBeTrue();
-      expect(DyFM_Math.around(5, 5, 1)).toBeTrue();
-      expect(DyFM_Math.around(4, 5, 1)).toBeTrue();
-      expect(DyFM_Math.around(6, 5, 1)).toBeTrue();
-    });
-
-    it('| should return false if value is outside the range of target', () => {
-      expect(DyFM_Math.around(3, 5, 1)).toBeFalse();
-      expect(DyFM_Math.around(7, 5, 1)).toBeFalse();
-    });
-  });
-
-  describe('| round', () => {
-    it('| should round a number to the specified number of decimals', () => {
-      expect(DyFM_Math.round(1.2345, 2)).toBe(1.23);
-      expect(DyFM_Math.round(1.2355, 2)).toBe(1.24);
-    });
-
-    it('| should round a number to the nearest integer if decimals is 0', () => {
-      expect(DyFM_Math.round(1.5, 0)).toBe(2);
-      expect(DyFM_Math.round(1.4, 0)).toBe(1);
-    });
-
-    it('| should round a number to the nearest multiple of 10 if decimals is negative', () => {
-      expect(DyFM_Math.round(123, -1)).toBe(120);
-      expect(DyFM_Math.round(125, -1)).toBe(130);
-    });
-  });
-
-  describe('| numberWithSpaces', () => {
-    it('| should format a number with spaces as thousand separators', () => {
-      expect(DyFM_Math.numberWithSpaces(1000)).toBe('1 000');
-      expect(DyFM_Math.numberWithSpaces(1000000)).toBe('1 000 000');
-    });
-  });
-
-  describe('| numberWithShorters', () => {
-    it('| should format a number with k, M, or B as appropriate', () => {
-      expect(DyFM_Math.numberWithShorters(999)).toBe('999');
-      expect(DyFM_Math.numberWithShorters(1000)).toBe('1.0k');
-      expect(DyFM_Math.numberWithShorters(1000000)).toBe('1.00M');
-      expect(DyFM_Math.numberWithShorters(1000000000)).toBe('1.000B');
-    });
-  });
-
-  describe('| numberWithShortersAndSpaces', () => {
-    it('| should format a number with shorters and spaces', () => {
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000)).toBe('1.0k');
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000000)).toBe('1.00M');
-      expect(DyFM_Math.numberWithShortersAndSpaces(1000000000)).toBe('1.000B');
-    });
-  });
-
-  describe('| floatingNumberWithSpaces', () => {
-    it('| should format a floating number with spaces as thousand separators', () => {
-      expect(DyFM_Math.floatingNumberWithSpaces(1234.567)).toBe('1 234.567');
-      expect(DyFM_Math.floatingNumberWithSpaces(1234567.89)).toBe('1 234 567.89');
-    });
-  });
-
-  describe('| decimals', () => {
-    it('| should format a number with a custom spacer', () => {
-      expect(DyFM_Math.decimals(1234.567, ',')).toBe('1,234.567');
-      expect(DyFM_Math.decimals(1234567.89, '.')).toBe('1.234.567.89');
-    });
-  });
-
-});

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

@@ -1,141 +0,0 @@
-
-
-
-/**
- * this class is a collection of static methods for mathematical operations
- */
-export class DyFM_Math {
-
-  /**
-   * returns true if the value is between the min and max
-   * 
-   * @example
-   * ```ts
-   * const isBetween = DyFM_Math.between(5, 1, 10);
-   * console.log(isBetween);
-   * ```
-   */
-  static between(value: number, minExclusive: number, maxExclusive: number): boolean {
-    return minExclusive < value && value < maxExclusive;
-  }
-
-  /**
-   * returns true if the value is between the target and the range
-   * 
-   * @example
-   * ```ts
-   * const isAround = DyFM_Math.around(5, 5, 1);
-   * console.log(isAround);
-   * ```
-   */
-  static around(value: number, target: number, range: number): boolean {
-    return this.between(value, target - range, target + range);
-  }
-
-  static readonly toFixed = this.round;
-  /**
-   * returns a number rounded to the specified number of decimals
-   * 
-   * @example
-   * ```ts
-   * const roundedNumber = DyFM_Math.round(1.2345, 2);
-   * console.log(roundedNumber); // 1.23
-   * ```
-   */
-  static round(value: number, decimals: number = 2): number {
-    if (0 <= decimals) {
-      return Number(value.toFixed(decimals));
-    } else {
-      const factor = Math.pow(10, -decimals);
-      
-      return Math.round(value / factor) * factor;
-    }
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const numberWithSpaces = DyFM_Math.numberWithSpaces(1000);
-   * console.log(numberWithSpaces); // '1 000'
-   * ```
-   */
-  static numberWithSpaces(x: number): string {
-    return x?.toString()?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  }
-
-  /**
-   * returns a number with shorter units
-   * 
-   * @example
-   * ```ts
-   * const numberWithShorters = DyFM_Math.numberWithShorters(1000);
-   * console.log(numberWithShorters); // '1.0k'
-   * ```
-   */
-  static numberWithShorters(x: number): string {
-    if (x < 1000) {
-      return x?.toString();
-    } else if (x < 1000000) {
-      return (x / 1000)?.toFixed(1) + 'k';
-    } else if (x < 1000000000) {
-      return (x / 1000000)?.toFixed(2) + 'M';
-    } else {
-      return (x / 1000000000)?.toFixed(3) + 'B';
-    }
-  }
-
-  /**
-   * returns a number with shorter units and spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const numberWithShortersAndSpaces = DyFM_Math.numberWithShortersAndSpaces(1000);
-   * console.log(numberWithShortersAndSpaces); // '1.0k'
-   * ```
-   */
-  static numberWithShortersAndSpaces(x: number): string {
-    return this.numberWithShorters(x)?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const floatingNumberWithSpaces = DyFM_Math.floatingNumberWithSpaces(1234.567);
-   * console.log(floatingNumberWithSpaces); // '1 234.567'
-   * ```
-   */
-  static floatingNumberWithSpaces(x: number): string {
-    const parts: string[] = x?.toString()?.split('.');
-
-    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, ' ');
-
-    return parts?.join('.');
-  }
-
-  /**
-   * returns a number with spaces between the thousands
-   * 
-   * @example
-   * ```ts
-   * const decimals = DyFM_Math.decimals(1234.567, ',');
-   * console.log(decimals); // '1,234.567'
-   * ```
-   */
-  static decimals(x: number, useSpacer: string = ','): string {
-    const parts: string[] = x?.toString()?.split('.');
-
-    parts[0] = parts?.[0]?.replace(/\B(?=(\d{3})+(?!\d))/g, useSpacer);
-
-    return parts?.join('.');
-  }
-}
-
-
-
-
-
-

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

@@ -1,82 +0,0 @@
-
-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: number[] = [1, 2, 3, 4, 5];
-      const result: number | null = DyFM_Random.getRandomListElement(list);
-      expect(list).toContain(result as number);
-    });
-
-    it('| should return null if the list is empty', () => {
-      const list: number[] = [];
-      const result: number | null = 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: string | null = DyFM_Random.getRandomWeighted(weights);
-      expect(['a', 'b', 'c']).toContain(result as string);
-    });
-
-    it('| should return null if weights array is empty', () => {
-      const weights: DyFM_RandomWeight<string>[] = [];
-      const result: string | null = DyFM_Random.getRandomWeighted(weights);
-      expect(result).toBeNull();
-    });
-  });
-});