@futdevpro/fsm-dynamo 1.7.14 → 1.8.2

package/src/_utils/vector2.util.ts

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

package/lib/_models/control-models/data-params.control-model.d.ts

@@ -1,13 +0,0 @@
-import { Dynamo_DataModelType } from '../../_enums';
-import { Dynamo_DataPropertyParams } from './data-property-params.control-model';
-export type D_DataParams = Dynamo_DataParams;
-export declare class Dynamo_DataParams {
-    dataName: string;
-    modelType?: Dynamo_DataModelType;
-    dbName?: string;
-    modelParams?: Dynamo_DataPropertyParams[];
-    /** format info */
-    logicalBreakpoints?: number[];
-    constructor(set: Dynamo_DataParams);
-}
-//# sourceMappingURL=data-params.control-model.d.ts.map

package/lib/_models/control-models/data-params.control-model.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-params.control-model.d.ts","sourceRoot":"","sources":["../../../src/_models/control-models/data-params.control-model.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEjF,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAC7C,qBAAa,iBAAiB;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,yBAAyB,EAAE,CAAM;IAE/C,kBAAkB;IAClB,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAM;gBAGjC,GAAG,EAAE,iBAAiB;CAWzB"}

package/lib/_models/control-models/data-params.control-model.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Dynamo_DataParams = void 0;
-const _enums_1 = require("../../_enums");
-class Dynamo_DataParams {
-    dataName;
-    modelType;
-    dbName;
-    modelParams = [];
-    /** format info */
-    logicalBreakpoints = [];
-    constructor(set) {
-        if (!set?.modelType || set?.modelType == _enums_1.Dynamo_DataModelType.dataModel) {
-            set.modelType = _enums_1.Dynamo_DataModelType.dataModel;
-            set.dbName = set.dataName.charAt(0).toUpperCase() + set.dataName.slice(1);
-        }
-        if (set) {
-            Object.assign(this, set);
-        }
-    }
-}
-exports.Dynamo_DataParams = Dynamo_DataParams;
-//# sourceMappingURL=data-params.control-model.js.map

package/lib/_models/control-models/data-params.control-model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"data-params.control-model.js","sourceRoot":"","sources":["../../../src/_models/control-models/data-params.control-model.ts"],"names":[],"mappings":";;;AACA,yCAAoD;AAIpD,MAAa,iBAAiB;IAC5B,QAAQ,CAAS;IACjB,SAAS,CAAwB;IACjC,MAAM,CAAU;IAChB,WAAW,GAAiC,EAAE,CAAC;IAE/C,kBAAkB;IAClB,kBAAkB,GAAc,EAAE,CAAC;IAEnC,YACE,GAAsB;QAEtB,IAAI,CAAC,GAAG,EAAE,SAAS,IAAI,GAAG,EAAE,SAAS,IAAI,6BAAoB,CAAC,SAAS,EAAE,CAAC;YACxE,GAAG,CAAC,SAAS,GAAG,6BAAoB,CAAC,SAAS,CAAC;YAC/C,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;CACF;AArBD,8CAqBC"}

package/src/_models/control-models/data-params.control-model.ts

@@ -1,27 +0,0 @@
-
-import { Dynamo_DataModelType } from '../../_enums';
-import { Dynamo_DataPropertyParams } from './data-property-params.control-model';
-
-export type D_DataParams = Dynamo_DataParams;
-export class Dynamo_DataParams {
-  dataName: string;
-  modelType?: Dynamo_DataModelType;
-  dbName?: string;
-  modelParams?: Dynamo_DataPropertyParams[] = [];
-
-  /** format info */
-  logicalBreakpoints?: number[] = []; 
-
-  constructor(
-    set: Dynamo_DataParams
-  ) {
-    if (!set?.modelType || set?.modelType == Dynamo_DataModelType.dataModel) {
-      set.modelType = Dynamo_DataModelType.dataModel;
-      set.dbName = set.dataName.charAt(0).toUpperCase() + set.dataName.slice(1);
-    }
-
-    if (set) {
-      Object.assign(this, set);
-    }
-  }
-}