@futdevpro/fsm-dynamo 1.16.5 → 1.16.7

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

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