@futdevpro/fsm-dynamo 1.8.4 → 1.9.1

package/src/_utils/utilities.util.ts

@@ -4,7 +4,7 @@ const defaultErrorMsg = ' failed. ' +
 'containes object hooks for its own objects, therefore its creating an object loop. ' +
 'See further information in the detailed error:\n\n';
 
-export function Dynamo_clone<T>(object: T): T {
+export function DynamoFM_clone<T>(object: T): T {
   try {
     return object ? JSON.parse(JSON.stringify(object)) as T : object;
   } catch (error) {
@@ -16,11 +16,11 @@ export function Dynamo_clone<T>(object: T): T {
     throw error;
   }
 }
-export const Dynamo_copy = Dynamo_clone;
-export const D_clone = Dynamo_clone;
-export const D_copy = Dynamo_clone;
+export const DynamoFM_copy = DynamoFM_clone;
+export const DFM_clone = DynamoFM_clone;
+export const DFM_copy = DynamoFM_clone;
 
-export function Dynamo_surfaceClone<T>(object: T): T {
+export function DynamoFM_surfaceClone<T>(object: T): T {
   try {
     const result = {};
 
@@ -38,11 +38,11 @@ export function Dynamo_surfaceClone<T>(object: T): T {
     throw error;
   }
 }
-export const Dynamo_surfaceCopy = Dynamo_surfaceClone;
-export const D_surfaceClone = Dynamo_surfaceClone;
-export const D_surfaceCopy = Dynamo_surfaceClone;
+export const DynamoFM_surfaceCopy = DynamoFM_surfaceClone;
+export const DFM_surfaceClone = DynamoFM_surfaceClone;
+export const DFM_surfaceCopy = DynamoFM_surfaceClone;
 
-export function Dynamo_sameObjects<T>(objA: T, objB: T): boolean {
+export function DynamoFM_sameObjects<T>(objA: T, objB: T): boolean {
   try {
     return JSON.stringify(objA) === JSON.stringify(objB);
   } catch (error) {
@@ -54,32 +54,32 @@ export function Dynamo_sameObjects<T>(objA: T, objB: T): boolean {
     throw error;
   }
 }
-export const D_sameObjects = Dynamo_sameObjects;
+export const DFM_sameObjects = DynamoFM_sameObjects;
 
 /**
  * sets values if its existing on To, even if its null (but if undefined)
  * @param setOn
  * @param setTo 
  */
-export function Dynamo_setExisitngValuesOnly(setOn: any, setTo: any): void {
+export function DynamoFM_setExisitngValuesOnly(setOn: any, setTo: any): void {
   for (const key in setTo) {
     if (setTo[key] != undefined) {
       setOn[key] = setTo[key];
     }
   }
 }
-export const D_setExisitngValuesOnly = Dynamo_setExisitngValuesOnly;
+export const DFM_setExisitngValuesOnly = DynamoFM_setExisitngValuesOnly;
 
-export function Dynamo_delay(ms: number): Promise<void> {
+export function DynamoFM_delay(ms: number): Promise<void> {
   return new Promise((resolve): any => setTimeout(resolve, ms));
 }
-export const Dynamo_sleep = Dynamo_delay;
-export const Dynamo_wait = Dynamo_delay;
-export const D_delay = Dynamo_delay;
-export const D_sleep = Dynamo_delay;
-export const D_wait = Dynamo_delay;
+export const DynamoFM_sleep = DynamoFM_delay;
+export const DynamoFM_wait = DynamoFM_delay;
+export const DFM_delay = DynamoFM_delay;
+export const DFM_sleep = DynamoFM_delay;
+export const DFM_wait = DynamoFM_delay;
 
-export type Dynamo_SortDirection = 0 | 1 | -1
+export type DynamoFM_SortDirection = 0 | 1 | -1
 
 /**
  * You might be use getSortForTrueFn instead for a shorter expression
@@ -92,12 +92,16 @@ export type Dynamo_SortDirection = 0 | 1 | -1
  * @example 
  * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
  */
-export function Dynamo_sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): Dynamo_SortDirection {
+export function DynamoFM_sortForTrue<T>(
+  a: T, 
+  b: T, 
+  check: (a: T) => boolean
+): DynamoFM_SortDirection {
   const isA = check(a);
 
   return isA === check(b) ? 0 : isA ? -1 : 1;
 }
-export const D_sortForTrue = Dynamo_sortForTrue;
+export const DFM_sortForTrue = DynamoFM_sortForTrue;
 
 /**
  * 
@@ -107,13 +111,13 @@ export const D_sortForTrue = Dynamo_sortForTrue;
  * @example
  * codes.sort(getSortForTrueFn((c: Code) => c.haveImg));
  */
-export function Dynamo_getSortForTrueFn<T>(
-  checkFor: (a: T) => boolean): (a: T, b: T) => Dynamo_SortDirection {
-  return (a: T, b: T): Dynamo_SortDirection => Dynamo_sortForTrue<T>(a, b, checkFor);
+export function DynamoFM_getSortForTrueFn<T>(
+  checkFor: (a: T) => boolean): (a: T, b: T) => DynamoFM_SortDirection {
+  return (a: T, b: T): DynamoFM_SortDirection => DynamoFM_sortForTrue<T>(a, b, checkFor);
 }
-export const D_getSortForTrueFn = Dynamo_getSortForTrueFn;
+export const DFM_getSortForTrueFn = DynamoFM_getSortForTrueFn;
 
-export function Dynamo_JSONListify<T>(JSONList): T[] {
+export function DynamoFM_JSONListify<T>(JSONList): T[] {
   const result: T[] = [];
 
   for (let i = 0; JSONList[i]; i++) {
@@ -122,5 +126,5 @@ export function Dynamo_JSONListify<T>(JSONList): T[] {
 
   return result; 
 }
-export const D_JSONListify = Dynamo_JSONListify;
+export const DFM_JSONListify = DynamoFM_JSONListify;
 

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/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
     "incremental": true,                  
-    "target": "es2022",                      
     "module": "commonjs",                 
+    "target": "es2022",                      
     "lib": [
       "es6",
       "es2018",
@@ -18,6 +18,7 @@
     "moduleResolution": "node", 
     "esModuleInterop": true,
     "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true 
   },

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;
-  }
-}
-
- */