@futdevpro/fsm-dynamo 1.8.5 → 1.9.1

package/src/_utils/vector2.util.ts

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

package/lib/_utils/metadata.util.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=metadata.util.d.ts.map

package/lib/_utils/metadata.util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.util.d.ts","sourceRoot":"","sources":["../../src/_utils/metadata.util.ts"],"names":[],"mappings":""}

package/lib/_utils/metadata.util.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/*
-export class Dynamo_Metadata_Tool {
-
-  static updateMetadata<T extends Dynamo_Metadata>(data: T, issuer: string, id?: string): T {
-    if (!data) {
-      return data;
-    }
-
-    if (!data._id && id) {
-      data._id = id;
-    }
-
-    if (!data.__created) {
-      data.__created = new Date();
-    }
-    
-    if (!data.__createdBy) {
-      data.__createdBy = issuer;
-    }
-
-    data.__lastModified = new Date();
-    data.__lastModifiedBy = issuer;
-    data.__v = data.__v ? data.__v + 1 : 1;
-
-    return data;
-  }
-}
-
- */ 
-//# sourceMappingURL=metadata.util.js.map

package/lib/_utils/metadata.util.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.util.js","sourceRoot":"","sources":["../../src/_utils/metadata.util.ts"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG"}

package/src/_utils/metadata.util.ts

@@ -1,31 +0,0 @@
-import { Dynamo_Metadata } from '../_models';
-
-/* 
-export class Dynamo_Metadata_Tool {
-
-  static updateMetadata<T extends Dynamo_Metadata>(data: T, issuer: string, id?: string): T {
-    if (!data) {
-      return data;
-    }
-
-    if (!data._id && id) {
-      data._id = id;
-    }
-
-    if (!data.__created) {
-      data.__created = new Date();
-    }
-    
-    if (!data.__createdBy) {
-      data.__createdBy = issuer;
-    }
-
-    data.__lastModified = new Date();
-    data.__lastModifiedBy = issuer;
-    data.__v = data.__v ? data.__v + 1 : 1;
-
-    return data;
-  }
-}
-
- */