@futdevpro/fsm-dynamo 1.9.15 → 1.9.17

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

@@ -1,35 +1,33 @@
 
-import { DynamoFM_LogStyle } from '../../_enums/log-style.enum';
+import { DyFM_LogStyle } from '../../_enums/log-style.enum';
 
-/* export class D_Log implements DynamoFM_Log {}; */
-export type DynamoFM_L = DynamoFM_Log;
-export type DFM_Log = DynamoFM_Log;
-export type DFM_L = DynamoFM_Log;
+/* export class D_Log implements DyFM_Log {}; */
+export type DyFM_L = DyFM_Log;
 
-export class DynamoFM_Log {
+export class DyFM_Log {
 
-  static setStyle(styles: DynamoFM_LogStyle[]): void {
+  static setStyle(styles: DyFM_LogStyle[]): void {
     let styleSets = '';
 
-    styles.forEach((style: DynamoFM_LogStyle): void => {
+    styles.forEach((style: DyFM_LogStyle): void => {
       styleSets += style;
     });
     console.log(styleSets);
   }
   static resetStyle(): void {
-    console.log(DynamoFM_LogStyle.reset);
+    console.log(DyFM_LogStyle.reset);
   }
 
-  static addStyle(input: string, styles: DynamoFM_LogStyle[], dontReset?: boolean): string {
+  static addStyle(input: string, styles: DyFM_LogStyle[], dontReset?: boolean): string {
     let result = '';
 
-    styles.forEach((style: DynamoFM_LogStyle): void => {
+    styles.forEach((style: DyFM_LogStyle): void => {
       result += style;
     });
     result += input;
 
     if (!dontReset) {
-      result += DynamoFM_LogStyle.reset;
+      result += DyFM_LogStyle.reset;
     }
 
     return result;
@@ -38,17 +36,17 @@ export class DynamoFM_Log {
   static success(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.log(
-        `${DynamoFM_LogStyle.green}${DynamoFM_LogStyle.bright}${message}`, 
-        ...optionalParams, DynamoFM_LogStyle.reset
+        `${DyFM_LogStyle.green}${DyFM_LogStyle.bright}${message}`, 
+        ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
       console.log(
-        `${DynamoFM_LogStyle.green}${DynamoFM_LogStyle.bright}${message}${DynamoFM_LogStyle.reset}`
+        `${DyFM_LogStyle.green}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
       );
     }
   }
   /** 
-   * @deprecated use DynamoFM_Log.success instead
+   * @deprecated use DyFM_Log.success instead
    */
   static logSuccess(message: string, ...optionalParams: any[]): void {
     this.success(message, ...optionalParams);
@@ -57,17 +55,17 @@ export class DynamoFM_Log {
   static error(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.error(
-        `${DynamoFM_LogStyle.red}${DynamoFM_LogStyle.bright}${message}`,
-        ...optionalParams, DynamoFM_LogStyle.reset
+        `${DyFM_LogStyle.red}${DyFM_LogStyle.bright}${message}`,
+        ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
       console.error(
-        `${DynamoFM_LogStyle.red}${DynamoFM_LogStyle.bright}${message}${DynamoFM_LogStyle.reset}`
+        `${DyFM_LogStyle.red}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
       );
     }
   }
   /** 
-   * @deprecated use DynamoFM_Log.error instead
+   * @deprecated use DyFM_Log.error instead
    */
   static logError(message: string, ...optionalParams: any[]): void {
     this.error(message, ...optionalParams);
@@ -76,23 +74,23 @@ export class DynamoFM_Log {
   static warn(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.warn(
-        `${DynamoFM_LogStyle.yellow}${DynamoFM_LogStyle.bright}${message}`, 
-        ...optionalParams, DynamoFM_LogStyle.reset
+        `${DyFM_LogStyle.yellow}${DyFM_LogStyle.bright}${message}`, 
+        ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
       console.warn(
-        `${DynamoFM_LogStyle.yellow}${DynamoFM_LogStyle.bright}${message}${DynamoFM_LogStyle.reset}`
+        `${DyFM_LogStyle.yellow}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
       );
     }
   }
   /** 
-   * @deprecated use DynamoFM_Log.warn instead
+   * @deprecated use DyFM_Log.warn instead
    */
   static warning(message: string, ...optionalParams: any[]): void {
     this.warn(message, ...optionalParams);
   }
   /** 
-   * @deprecated use DynamoFM_Log.warn instead
+   * @deprecated use DyFM_Log.warn instead
    */
   static logWarning(message: string, ...optionalParams: any[]): void {
     this.warn(message, ...optionalParams);
@@ -109,12 +107,12 @@ export class DynamoFM_Log {
   static highlighted(message: string, ...optionalParams: any[]): void {
     if (0 < optionalParams.length) {
       console.log(
-        `${DynamoFM_LogStyle.white}${DynamoFM_LogStyle.bright}${message}`, 
-        ...optionalParams, DynamoFM_LogStyle.reset
+        `${DyFM_LogStyle.white}${DyFM_LogStyle.bright}${message}`, 
+        ...optionalParams, DyFM_LogStyle.reset
       );
     } else {
       console.log(
-        `${DynamoFM_LogStyle.white}${DynamoFM_LogStyle.bright}${message}${DynamoFM_LogStyle.reset}`
+        `${DyFM_LogStyle.white}${DyFM_LogStyle.bright}${message}${DyFM_LogStyle.reset}`
       );
     }
   }
@@ -123,7 +121,7 @@ export class DynamoFM_Log {
     this.log(message, ...optionalParams);
     this.log('\n' + this.h_solid + '\n\n');
   }  
-  static test = DynamoFM_Log.testLog;
+  static test = DyFM_Log.testLog;
   
   static highlightedLog(message: string, ...optionalParams: any[]): void {
     this.log('\n\n' + this.h_before);
@@ -134,7 +132,7 @@ export class DynamoFM_Log {
     this.log(' ' + this.h_after);
     this.log(this.h_after + '\n\n');
   }  
-  static H_log = DynamoFM_Log.highlightedLog;
+  static H_log = DyFM_Log.highlightedLog;
 
   static testInfo(message: string, ...optionalParams: any[]): void {
     this.info('\n\n' + this.h_solid + '\n');
@@ -151,7 +149,7 @@ export class DynamoFM_Log {
     this.info(' ' + this.h_after);
     this.info(this.h_after + '\n\n');
   }
-  static H_info = DynamoFM_Log.highlightedInfo;
+  static H_info = DyFM_Log.highlightedInfo;
 
   static testError(message: string, ...optionalParams: any[]): void {
     this.error('\n\n' + this.h_solid + '\n');
@@ -168,7 +166,7 @@ export class DynamoFM_Log {
     this.error(' ' + this.h_after);
     this.error(this.h_after + '\n\n');
   }  
-  static H_error = DynamoFM_Log.highlightedError;
+  static H_error = DyFM_Log.highlightedError;
 
   static testWarn(message: string, ...optionalParams: any[]): void {
     this.warn('\n\n' + this.h_solid + '\n');
@@ -185,7 +183,7 @@ export class DynamoFM_Log {
     this.warn(' ' + this.h_after);
     this.warn(this.h_after + '\n\n');
   }  
-  static H_warn = DynamoFM_Log.highlightedWarn;
+  static H_warn = DyFM_Log.highlightedWarn;
 
   static testSuccess(message: string, ...optionalParams: any[]): void {
     this.success('\n\n' + this.h_solid + '\n');
@@ -202,7 +200,7 @@ export class DynamoFM_Log {
     this.success(' ' + this.h_after);
     this.success(this.h_after + '\n\n');
   } 
-  static H_success = DynamoFM_Log.highlightedSuccess;
+  static H_success = DyFM_Log.highlightedSuccess;
 
   // eslint-disable-next-line max-len
   private static h_solid: string =  '|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||';
@@ -212,8 +210,8 @@ export class DynamoFM_Log {
   private static h_after: string =  '/////////////////////////////////////////////////////////////////////////////';
 
   static removeLogStyles(message: string): string {
-    for (const styleKey of Object(DynamoFM_LogStyle)) {
-      message = message.replace(new RegExp(DynamoFM_LogStyle[styleKey], 'g'), '');
+    for (const styleKey of Object(DyFM_LogStyle)) {
+      message = message.replace(new RegExp(DyFM_LogStyle[styleKey], 'g'), '');
     }
 
     return message;

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

@@ -1,41 +1,41 @@
 
 
-import { DynamoFM_Vector2 } from './vector2.util';
+import { DyFM_Vector2 } from './vector2.util';
 
-export class DynamoFM_BoxBounds {
-  private _pos: DynamoFM_Vector2;
-  set pos(value: DynamoFM_Vector2) {
+export class DyFM_BoxBounds {
+  private _pos: DyFM_Vector2;
+  set pos(value: DyFM_Vector2) {
     this._pos = value;
 
     this.calcCenter();
   }
-  get pos(): DynamoFM_Vector2 { 
+  get pos(): DyFM_Vector2 { 
     return this._pos;
   }
 
-  private _size: DynamoFM_Vector2;
-  set size(value: DynamoFM_Vector2) {
+  private _size: DyFM_Vector2;
+  set size(value: DyFM_Vector2) {
     this._size = value;
     
     this.calcCenter();
   }
-  get size(): DynamoFM_Vector2 { 
+  get size(): DyFM_Vector2 { 
     return this._size;
   }
 
-  private _center: DynamoFM_Vector2;
-  get center(): DynamoFM_Vector2 {
+  private _center: DyFM_Vector2;
+  get center(): DyFM_Vector2 {
     return this._center;
   }
 
-  private _centerMargin: DynamoFM_Vector2;
-  get centerMargin(): DynamoFM_Vector2 {
+  private _centerMargin: DyFM_Vector2;
+  get centerMargin(): DyFM_Vector2 {
     return this._centerMargin;
   }
 
   constructor(
-    position: DynamoFM_Vector2 = new DynamoFM_Vector2(), 
-    size: DynamoFM_Vector2 = new DynamoFM_Vector2()
+    position: DyFM_Vector2 = new DyFM_Vector2(), 
+    size: DyFM_Vector2 = new DyFM_Vector2()
   ) {
     this._pos = position;
     this._size = size;
@@ -47,7 +47,7 @@ export class DynamoFM_BoxBounds {
     return true; 
   }
 
-  newValues?(position: DynamoFM_Vector2, size: DynamoFM_Vector2): void {
+  newValues?(position: DyFM_Vector2, size: DyFM_Vector2): void {
     if (position === undefined) {
       throw new Error('new position is undefined!');
     }
@@ -62,23 +62,23 @@ export class DynamoFM_BoxBounds {
     this.calcCenter();
   }
 
-  static bounds(box: DynamoFM_BoxBounds, position: DynamoFM_Vector2): boolean {
+  static bounds(box: DyFM_BoxBounds, 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;
   }
-  bounds?(position: DynamoFM_Vector2): boolean {
-    return DynamoFM_BoxBounds.bounds(this, position);
+  bounds?(position: DyFM_Vector2): boolean {
+    return DyFM_BoxBounds.bounds(this, position);
   }
 
   private calcCenter?(): void {
-    const halfSize = DynamoFM_Vector2.divide(this.size, 2);
+    const halfSize = DyFM_Vector2.divide(this.size, 2);
 
-    this._center = DynamoFM_Vector2.plus(this.pos, halfSize);
-    this._centerMargin = DynamoFM_Vector2.negative(halfSize);
+    this._center = DyFM_Vector2.plus(this.pos, halfSize);
+    this._centerMargin = DyFM_Vector2.negative(halfSize);
   }
 
-  clone?(): DynamoFM_BoxBounds {
-    return new DynamoFM_BoxBounds(this.pos.clone(), this.size.clone());
+  clone?(): DyFM_BoxBounds {
+    return new DyFM_BoxBounds(this.pos.clone(), this.size.clone());
   }
 }
 

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

@@ -7,7 +7,7 @@
 
 
 
-export class DynamoFM_Math {
+export class DyFM_Math {
 
   static between(value: number, minExclusive: number, maxExclusive: number): boolean {
     return minExclusive < value && value < maxExclusive;

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

@@ -1,12 +1,11 @@
 
-import { DynamoFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
+import { DyFM_RandomWeight } from '../../../_models/interfaces/random-weight.interface';
 
-export type DFM_Random = DynamoFM_Random;
-export class DynamoFM_Random {
+export class DyFM_Random {
   static getRandomWeightedInt(
     min: number, 
     max: number, 
-    weights: DynamoFM_RandomWeight<number>[]
+    weights: DyFM_RandomWeight<number>[]
   ): number {
     weights = weights.sort((a, b): number => b.chance - a.chance);
     let weightChanceSum = 0;
@@ -48,7 +47,7 @@ export class DynamoFM_Random {
     }
   }
   
-  static getRandomWeighted<T>(weights: DynamoFM_RandomWeight<T>[]): T {
+  static getRandomWeighted<T>(weights: DyFM_RandomWeight<T>[]): T {
     if (!weights?.length) {
       return null;
     }

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

@@ -1,8 +1,7 @@
 
-export type DFM_Trigonometry = DynamoFM_Trigonometry;
-export type DFM_Trig = DynamoFM_Trigonometry;
-export type DFM_Δ = DynamoFM_Trigonometry;
-export class DynamoFM_Trigonometry {
+export type DyFM_Trig = DyFM_Trigonometry;
+export type DyFM_Δ = DyFM_Trigonometry;
+export class DyFM_Trigonometry {
   
   /**
    * Befogó

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

@@ -1,8 +1,8 @@
 
-import { DynamoFM_Trigonometry } from './trigonometry.util';
+import { DyFM_Trigonometry } from './trigonometry.util';
 
-export type DFM_Vector2 = DynamoFM_Vector2;
-export class DynamoFM_Vector2 {
+export type DyFM_V2 = DyFM_Vector2;
+export class DyFM_Vector2 {
   readonly isVector2: boolean = true;
 
   private _x: number = 0;
@@ -30,18 +30,18 @@ export class DynamoFM_Vector2 {
     return this._magintude;
   }
 
-  static readonly zero: DynamoFM_Vector2 = new DynamoFM_Vector2(0, 0);
-  static readonly up: DynamoFM_Vector2 = new DynamoFM_Vector2(0, 1);
-  static readonly down: DynamoFM_Vector2 = new DynamoFM_Vector2(0, -1);
-  static readonly right: DynamoFM_Vector2 = new DynamoFM_Vector2(1, 0);
-  static readonly left: DynamoFM_Vector2 = new DynamoFM_Vector2(-1, 0);
+  static readonly zero: DyFM_Vector2 = new DyFM_Vector2(0, 0);
+  static readonly up: DyFM_Vector2 = new DyFM_Vector2(0, 1);
+  static readonly down: DyFM_Vector2 = new DyFM_Vector2(0, -1);
+  static readonly right: DyFM_Vector2 = new DyFM_Vector2(1, 0);
+  static readonly left: DyFM_Vector2 = new DyFM_Vector2(-1, 0);
 
   constructor(
-    x: number | DynamoFM_Vector2 = 0, 
+    x: number | DyFM_Vector2 = 0, 
     y: number = 0
   ) {
-    if ((x as DynamoFM_Vector2).isVector2) {
-      const v = x as DynamoFM_Vector2;
+    if ((x as DyFM_Vector2).isVector2) {
+      const v = x as DyFM_Vector2;
 
       x = v.x;
       y = v.y;
@@ -57,83 +57,83 @@ export class DynamoFM_Vector2 {
     return true; 
   }
   
-  static distance(a: DynamoFM_Vector2, b: DynamoFM_Vector2): number {
+  static distance(a: DyFM_Vector2, b: DyFM_Vector2): number {
     return this.minus(a, b).magintude;
   }
-  distanceTo?(to: DynamoFM_Vector2): number {
-    return DynamoFM_Vector2.distance(this, to);
+  distanceTo?(to: DyFM_Vector2): number {
+    return DyFM_Vector2.distance(this, to);
   }
 
-  static minus(a: DynamoFM_Vector2, b: DynamoFM_Vector2): DynamoFM_Vector2 {
+  static minus(a: DyFM_Vector2, b: DyFM_Vector2): DyFM_Vector2 {
     return this.plus(a, this.negative(b));
   }
-  minus?(vector: DynamoFM_Vector2): void {
-    this.newValues(DynamoFM_Vector2.minus(this, vector));
+  minus?(vector: DyFM_Vector2): void {
+    this.newValues(DyFM_Vector2.minus(this, vector));
   }
 
-  static plus(a: DynamoFM_Vector2, b: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(a.x + b.x, a.y + b.y);
+  static plus(a: DyFM_Vector2, b: DyFM_Vector2): DyFM_Vector2 {
+    return new DyFM_Vector2(a.x + b.x, a.y + b.y);
   }
-  plus?(vector: DynamoFM_Vector2): void {
-    this.newValues(DynamoFM_Vector2.plus(this, vector));
+  plus?(vector: DyFM_Vector2): void {
+    this.newValues(DyFM_Vector2.plus(this, vector));
   }
   static add = this.plus;
   add? = this.plus;
 
   /** returns new multiplied Vector2 */
-  static multiply(v: DynamoFM_Vector2, n: number): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(v.x * n, v.y * n);
+  static multiply(v: DyFM_Vector2, n: number): DyFM_Vector2 {
+    return new DyFM_Vector2(v.x * n, v.y * n);
   }
   multiply?(n: number): void {
-    this.newValues(DynamoFM_Vector2.multiply(this, n));
+    this.newValues(DyFM_Vector2.multiply(this, n));
   }
 
   /** returns new divided Vector2 */
-  static divide(v: DynamoFM_Vector2, n: number): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(v.x / n, v.y / n);
+  static divide(v: DyFM_Vector2, n: number): DyFM_Vector2 {
+    return new DyFM_Vector2(v.x / n, v.y / n);
   }
   divide?(n: number): void {
-    this.newValues(DynamoFM_Vector2.divide(this, n));
+    this.newValues(DyFM_Vector2.divide(this, n));
   }
 
-  static negative(v: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(-v.x, -v.y);
+  static negative(v: DyFM_Vector2): DyFM_Vector2 {
+    return new DyFM_Vector2(-v.x, -v.y);
   }
-  getNegative?(): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.negative(this);
+  getNegative?(): DyFM_Vector2 {
+    return DyFM_Vector2.negative(this);
   }
   negate?(): void {
-    this.newValues(DynamoFM_Vector2.negative(this));
+    this.newValues(DyFM_Vector2.negative(this));
   }
 
-  static rebase(v: DynamoFM_Vector2, baseFrom: DynamoFM_Vector2, baseTo: DynamoFM_Vector2): DynamoFM_Vector2 {
+  static rebase(v: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2 {
     return this.plus(v, this.minus(baseTo, baseFrom));
   }
-  rebase?(baseFrom: DynamoFM_Vector2, baseTo: DynamoFM_Vector2): void {
-    this.newValues(DynamoFM_Vector2.rebase(this, baseFrom, baseTo));
+  rebase?(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): void {
+    this.newValues(DyFM_Vector2.rebase(this, baseFrom, baseTo));
   }
 
-  static rotate(vector: DynamoFM_Vector2, angle: number): DynamoFM_Vector2 {
-    const rad = DynamoFM_Trigonometry.angleToRadians(angle);
+  static rotate(vector: DyFM_Vector2, angle: number): DyFM_Vector2 {
+    const rad = DyFM_Trigonometry.angleToRadians(angle);
 
     return this.rotateRad(vector, rad);
   }
-  static rotateRad(vector: DynamoFM_Vector2, rad: number): DynamoFM_Vector2 {
+  static rotateRad(vector: DyFM_Vector2, rad: number): DyFM_Vector2 {
     const cos = Math.cos(rad);
     const sin = Math.sin(rad);
     const newX = (vector.x * cos) - (vector.y * sin);
     const newY = (vector.x * sin) + (vector.y * cos);
 
-    return new DynamoFM_Vector2(newX, newY);
+    return new DyFM_Vector2(newX, newY);
   }
   rotate?(angle: number): void {
-    this.newValues(DynamoFM_Vector2.rotate(this, angle));
+    this.newValues(DyFM_Vector2.rotate(this, angle));
   }
   rotateRad?(rad: number): void {
-    this.newValues(DynamoFM_Vector2.rotateRad(this, rad));
+    this.newValues(DyFM_Vector2.rotateRad(this, rad));
   }
 
-  private newValues(newV: DynamoFM_Vector2): void {
+  private newValues(newV: DyFM_Vector2): void {
     this.newXY(newV.x, newV.y);
   }
   newXY?(newX: number, newY: number): void {
@@ -144,55 +144,55 @@ export class DynamoFM_Vector2 {
   }
 
   //// AI-ed
-  angle?(from: DynamoFM_Vector2, to: DynamoFM_Vector2): number {
-    return DynamoFM_Vector2.angle(from, to);
+  angle?(from: DyFM_Vector2, to: DyFM_Vector2): number {
+    return DyFM_Vector2.angle(from, to);
   }
-  static angle(from: DynamoFM_Vector2, to: DynamoFM_Vector2): number {
-    return DynamoFM_Trigonometry.radiansToAngle(DynamoFM_Vector2.angleRad(from, to));
+  static angle(from: DyFM_Vector2, to: DyFM_Vector2): number {
+    return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2.angleRad(from, to));
   }
-  static angleRad(from: DynamoFM_Vector2, to: DynamoFM_Vector2): number {
+  static angleRad(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return Math.atan2(to.y - from.y, to.x - from.x);
   }
   deg?(): number {
-    return DynamoFM_Vector2.deg(this);
+    return DyFM_Vector2.deg(this);
   }
-  static deg(vector: DynamoFM_Vector2): number {
-    return DynamoFM_Trigonometry.radiansToAngle(DynamoFM_Vector2.rad(vector));
+  static deg(vector: DyFM_Vector2): number {
+    return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2.rad(vector));
   }
-  static rad(vector: DynamoFM_Vector2): number {
+  static rad(vector: DyFM_Vector2): number {
     return Math.atan2(vector.y, vector.x);
   }
 
-  floor?(): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.floor(this);
+  floor?(): DyFM_Vector2 {
+    return DyFM_Vector2.floor(this);
   }
-  static floor(v: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(Math.floor(v.x), Math.floor(v.y));
+  static floor(v: DyFM_Vector2): DyFM_Vector2 {
+    return new DyFM_Vector2(Math.floor(v.x), Math.floor(v.y));
   }
   /////
 
-  direction?(to: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.direction(this, to);
+  direction?(to: DyFM_Vector2): DyFM_Vector2 {
+    return DyFM_Vector2.direction(this, to);
   }
-  static direction(from: DynamoFM_Vector2, to: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.minus(to, from);
+  static direction(from: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2 {
+    return DyFM_Vector2.minus(to, from);
   }
 
-  static normalize(v: DynamoFM_Vector2): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.multiply(v, 1 / v.magintude);
+  static normalize(v: DyFM_Vector2): DyFM_Vector2 {
+    return DyFM_Vector2.multiply(v, 1 / v.magintude);
   }
   normalize?(): void {
-    this.newValues(DynamoFM_Vector2.normalize(this));
+    this.newValues(DyFM_Vector2.normalize(this));
   }
-  normalized?(): DynamoFM_Vector2 {
-    return DynamoFM_Vector2.normalize(this);
+  normalized?(): DyFM_Vector2 {
+    return DyFM_Vector2.normalize(this);
   }
 
   private calcMagnitude?(): void {
-    this._magintude = DynamoFM_Trigonometry.getHypotenuse(this._x, this._y);
+    this._magintude = DyFM_Trigonometry.getHypotenuse(this._x, this._y);
   }
 
-  clone?(): DynamoFM_Vector2 {
-    return new DynamoFM_Vector2(this._x, this._y);
+  clone?(): DyFM_Vector2 {
+    return new DyFM_Vector2(this._x, this._y);
   }
 }

package/src/_collections/utils/pipe-transforms/country-pipe.util.ts

@@ -5,13 +5,13 @@
 
 
 
-import { DynamoFM_CountryISO } from '../../../_models';
-import { DynamoFM_countryISOs } from '../../constants/courtry-isos.const';
+import { DyFM_CountryISO } from '../../../_models';
+import { DyFM_countryISOs } from '../../constants/courtry-isos.const';
 
 
-export function DynamoFM_country_pipeTransform(countryISO: string): string {
-  const result = DynamoFM_countryISOs.find(
-    (iso: DynamoFM_CountryISO): boolean => iso.iso2 === countryISO
+export function DyFM_country_pipeTransform(countryISO: string): string {
+  const result = DyFM_countryISOs.find(
+    (iso: DyFM_CountryISO): boolean => iso.iso2 === countryISO
   )?.name;
 
   return result ?? countryISO;

package/src/_collections/utils/pipe-transforms/custom-pipe.util.ts

@@ -4,6 +4,6 @@
 
 
 
-export function DynamoFM_custom_pipeTransform<T, K>(value: T, customTransform: (input: T) => K): K {
+export function DyFM_custom_pipeTransform<T, K>(value: T, customTransform: (input: T) => K): K {
   return customTransform(value);
 }

package/src/_collections/utils/pipe-transforms/division-pipe.util.ts

@@ -8,12 +8,12 @@
 
 
 
-import { DynamoFM_CountryDivision } from '../../../_models';
-import { DynamoFM_countryDivisions } from '../../constants/country-divisions.const';
+import { DyFM_CountryDivision } from '../../../_models';
+import { DyFM_countryDivisions } from '../../constants/country-divisions.const';
 
-export function DynamoFM_division_pipeTransform(divisionCode: string, countryISO: string): string {
-  const result: string = DynamoFM_countryDivisions?.find(
-    (d: DynamoFM_CountryDivision): boolean => d?.code === divisionCode && d?.iso === countryISO
+export function DyFM_division_pipeTransform(divisionCode: string, countryISO: string): string {
+  const result: string = DyFM_countryDivisions?.find(
+    (d: DyFM_CountryDivision): boolean => d?.code === divisionCode && d?.iso === countryISO
   )?.name;
 
   return result ?? divisionCode;

package/src/_collections/utils/pipe-transforms/list-pipe.util.ts

@@ -5,6 +5,6 @@
 
 
 
-export function DynamoFM_list_pipeTransform(value: any[]): string {
+export function DyFM_list_pipeTransform(value: any[]): string {
   return value.toString().replace(/,/g, ', ');  
 }