@futdevpro/fsm-dynamo 1.10.37 → 1.10.39

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

@@ -50,10 +50,25 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
 
   // these are created as soft objects to avoid changing instances with DyFM_Vector2 instance functions
+  /**
+   * zero vector
+   */
   static readonly zero: DyFM_Vector2 = { x: 0, y: 0 };
+  /**
+   * up vector
+   */
   static readonly up: DyFM_Vector2 = { x: 0, y: 1 };
+  /**
+   * down vector
+   */
   static readonly down: DyFM_Vector2 = { x: 0, y: -1 };
+  /**
+   * right vector
+   */
   static readonly right: DyFM_Vector2 = { x: 1, y: 0 };
+  /**
+   * left vector
+   */
   static readonly left: DyFM_Vector2 = { x: -1, y: 0 };
 
   constructor(
@@ -78,42 +93,54 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     this.calcMagnitude();
   }
 
+  /**
+   * returns true if the vector is constructed
+   */
   constructed?(): boolean { 
     return true; 
   }
   
+  /**
+   * returns the distance between two vectors
+   */
   static distance(a: DyFM_Vector2, b: DyFM_Vector2): number {
     return this.minus(a, b).magintude;
   }
-  distance?(to: DyFM_Vector2): number {
+  distance(to: DyFM_Vector2): number {
     return DyFM_Vector2_Util.distance(this, to);
   }
 
+  /**
+   * returns a new vector with the negative values of the original vector
+   */
   static minus(a: DyFM_Vector2, minusB: DyFM_Vector2): DyFM_Vector2_Util {
     return this.plus(a, this.negative(minusB));
   }
-  minus?(vector: DyFM_Vector2): this {
+  minus(vector: DyFM_Vector2): this {
     this.plus(DyFM_Vector2_Util.negative(vector));
 
     return this;
   }
 
+  /**
+   * returns a new vector with the sum of two vectors
+   */
   static plus(a: DyFM_Vector2, plusB: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(a.x + plusB.x, a.y + plusB.y);
   }
-  plus?(vector: DyFM_Vector2): this {
+  plus(vector: DyFM_Vector2): this {
     this.newValues(DyFM_Vector2_Util.plus(this, vector));
 
     return this;
   }
   static readonly add = this.plus;
-  readonly add? = this.plus;
+  readonly add = this.plus;
 
   /** returns new multiplied Vector2 */
   static multiply(v: DyFM_Vector2, n: number): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(v.x * n, v.y * n);
   }
-  multiply?(n: number): this {
+  multiply(n: number): this {
     return this.newValues(DyFM_Vector2_Util.multiply(this, n));
   }
 
@@ -121,7 +148,7 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   static divide(v: DyFM_Vector2, divideBy: number): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(v.x / divideBy, v.y / divideBy);
   }
-  divide?(n: number): this {
+  divide(n: number): this {
     this.newValues(DyFM_Vector2_Util.divide(this, n));
 
     return this;
@@ -131,29 +158,38 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     return new DyFM_Vector2_Util(-v.x, -v.y);
   }
   /** this returns a new instance */
-  getNegative?(): DyFM_Vector2_Util {
+  getNegative(): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.negative(this);
   }
-  negate?(): this {
+  negate(): this {
     this.newValues(DyFM_Vector2_Util.negative(this));
 
     return this;
   }
 
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
   static rebase(v: DyFM_Vector2, baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): DyFM_Vector2_Util {
     return this.plus(v, this.minus(baseTo, baseFrom));
   }
-  rebase?(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this {
+  rebase(baseFrom: DyFM_Vector2, baseTo: DyFM_Vector2): this {
     this.newValues(DyFM_Vector2_Util.rebase(this, baseFrom, baseTo));
 
     return this;
   }
 
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
   static rotate(vector: DyFM_Vector2, angle: number): DyFM_Vector2_Util {
     const rad = DyFM_Trigonometry.angleToRadians(angle);
 
     return this.rotateRad(vector, rad);
   }
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
   static rotateRad(vector: DyFM_Vector2, rad: number): DyFM_Vector2_Util {
     const cos = Math.cos(rad);
     const sin = Math.sin(rad);
@@ -162,23 +198,35 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
     return new DyFM_Vector2_Util(newX, newY);
   }
-  rotate?(angle: number): this {
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
+  rotate(angle: number): this {
     this.newValues(DyFM_Vector2_Util.rotate(this, angle));
 
     return this;
   }
-  rotateRad?(rad: number): this {
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
+  rotateRad(rad: number): this {
     this.newValues(DyFM_Vector2_Util.rotateRad(this, rad));
 
     return this;
   }
 
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
   newValues(newV: DyFM_Vector2): this {
     this.newXY(newV.x, newV.y);
 
     return this;
   }
-  newXY?(newX: number, newY: number): this {
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
+  newXY(newX: number, newY: number): this {
     this._x = newX;
     this._y = newY;
 
@@ -186,89 +234,159 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
 
     return this;
   }
+  /**
+   * returns a new vector with the sum of a vector and the difference of two vectors
+   */
+  static newValues(to: DyFM_Vector2, newV: DyFM_Vector2): DyFM_Vector2 {
+    to.x = newV.x;
+    to.y = newV.y;
+
+    return to;
+  }
+  static readonly newXY = this.newValues;
 
   //// AI-ed UNCHECKED
+  /**
+   * returns the angle between two vectors
+   */
   static angle(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.angleRad(from, to));
   }
+  /**
+   * returns the angle between two vectors in radians
+   */
   static angleRad(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return Math.atan2(to.y - from.y, to.x - from.x);
   }
-  angle?(from: DyFM_Vector2, to: DyFM_Vector2): number {
+  /**
+   * returns the angle between two vectors
+   */
+  angle(from: DyFM_Vector2, to: DyFM_Vector2): number {
     return DyFM_Vector2_Util.angle(from, to);
   }
+  /**
+   * returns the angle between two vectors in degrees
+   */
   static deg(vector: DyFM_Vector2): number {
     return DyFM_Trigonometry.radiansToAngle(DyFM_Vector2_Util.rad(vector));
   }
+  /**
+   * returns the angle between two vectors in radians
+   */
   static rad(vector: DyFM_Vector2): number {
     return Math.atan2(vector.y, vector.x);
   }
-  deg?(): number {
+  /**
+   * returns the angle between two vectors in degrees
+   */
+  deg(): number {
     return DyFM_Vector2_Util.deg(this);
   }
 
+  /**
+   * returns math floor of the vector
+   */
   static floor(v: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(Math.floor(v.x), Math.floor(v.y));
   }
-  floor?(): DyFM_Vector2_Util {
+  /**
+   * returns math floor of the vector
+   */
+  floor(): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.floor(this);
   }
   /////
 
+  /**
+   * returns the direction vector from one point to another
+   */
   static direction(from: DyFM_Vector2, to: DyFM_Vector2): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.minus(to, from);
   }
-  direction?(to: DyFM_Vector2): DyFM_Vector2_Util {
+  /**
+   * returns the direction vector from one point to another
+   */
+  direction(to: DyFM_Vector2): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.direction(this, to);
   }
 
+  /**
+   * returns a normalized vector
+   */
   static normalize(v: DyFM_Vector2): DyFM_Vector2_Util {
     const v_U = new DyFM_Vector2_Util(v);
 
     return v_U.multiply(1 / v_U.magintude);
   }
-  normalize?(): void {
+  /**
+   * returns a normalized vector
+   */
+  normalize(): void {
     this.newValues(DyFM_Vector2_Util.normalize(this));
   }
   /** 
    * this will return a new instance, 
    * if you want to change the current instance, use normalize()
   */
-  normalized?(): DyFM_Vector2_Util {
+  normalized(): DyFM_Vector2_Util {
     return DyFM_Vector2_Util.normalize(this);
   }
 
-  private calcMagnitude?(): void {
+  /**
+   * returns the magnitude of the vector
+   */
+  private calcMagnitude(): void {
     this._magintude = DyFM_Trigonometry.getHypotenuse(this._x, this._y);
   }
 
-  clone?(): DyFM_Vector2_Util {
+  /**
+   * returns a new vector with the same values
+   */
+  clone(): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(this._x, this._y);
   }
 
+  /**
+   * returns true if the vector has changed
+   */
   static isChanged(a: DyFM_Vector2_Util, b: DyFM_Vector2_Util): boolean {
     return a.x !== b.x || a.y !== b.y;
   }
 
+  /**
+   * returns true if the vectors are equal
+   */
   static isEqual(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
     return a.x === b.x && a.y === b.y;
   }
 
+  /**
+   * returns true if the vectors are equal
+   */
   static vectorChanged(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
     return a.x !== b.x || a.y !== b.y;
   }
 
+  /**
+   * returns true if the vectors are equal
+   */
   static equals(a: DyFM_Vector2, b: DyFM_Vector2): boolean {
     return a.x === b.x && a.y === b.y;
   }
 
+  /**
+   * returns a new vector with the absolute values of the original vector
+   */
   static abs(v: DyFM_Vector2): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(Math.abs(v.x), Math.abs(v.y));
   }
-  abs?(): this {
+  abs(): this {
     return this.newXY(Math.abs(this.x), Math.abs(this.y));
   }
 
+  /**
+   * returns a new vector with the rounded values of the original vector
+   */
   static round(v: DyFM_Vector2, decimals: number = 0): DyFM_Vector2_Util {
     return new DyFM_Vector2_Util(
       DyFM_Math.round(v.x, decimals),
@@ -276,16 +394,25 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
     );
   }
 
+  /**
+   * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+   */
   static toVector2(v: DyFM_Vector2_Util): DyFM_Vector2 {
     return (new DyFM_Vector2_Util(v)).get();
   }
 
+  /**
+   * returns a instance of DyFM_Vector2 from a DyFM_Vector2_Util
+   */
   get(): DyFM_Vector2 {
     return { x: this.x, y: this.y };
   }
   getVector2 = this.get;
   toVector2 = this.get;
 
+  /**
+   * returns a new vector with the same values
+   */
   static clone(v: DyFM_Vector2): DyFM_Vector2 {
     return { x: v.x, y: v.y };
   }

package/src/_collections/utils/round-list.util.ts

@@ -1,8 +1,17 @@
 
 
-
-
+/**
+ * This class is a collection of static methods for round list operations
+ * A round list is a list that is circular
+ * - after the last element, the first comes next
+ */
 export class DyFM_RoundList {  
+  /**
+   * returns the outbound index of the list
+   * @param listLength 
+   * @param outboundIndex 
+   * @returns 
+   */
   static getOutboundedIndex(listLength: number, outboundIndex: number): number {
     if (!listLength) {
       throw new Error('roundListPlusIndex failed. list is empty!');
@@ -20,6 +29,14 @@ export class DyFM_RoundList {
     return outboundIndex;
   }
   
+  /**
+   * returns the index of the opposite element of the list
+   * - as they are circular, the opposite is at the half of the list
+   * - as it is circular, for the second half, the opposite is at the first half
+   * @param length 
+   * @param oppositeOf 
+   * @returns 
+   */
   static getIndexOpposite(length: number, oppositeOf: number): number {
     const plusIndex = oppositeOf + Math.round(length / 2);
     const res = this.getOutboundedIndex(length, plusIndex);
@@ -27,15 +44,31 @@ export class DyFM_RoundList {
     return res;
   }
   
+  /**
+   * returns the element at the outbound index of the list
+   * @param list 
+   * @param outboundIndex 
+   * @returns 
+   */
   static getListIndex<T>(list: T[], outboundIndex: number): T {
     return list[this.getOutboundedIndex(list.length, outboundIndex)];
   }
   
+  /**
+   * returns the element at the opposite index of the list
+   * @param list 
+   * @param oppositeOf 
+   * @returns 
+   */
   static getListOpposite<T>(list: T[], oppositeOf: T): T {
     return list[this.getIndexOpposite(list.length, list.indexOf(oppositeOf))];
   }
   
-  static getLast<T>(list: T[]): T {
+  /**
+   * returns the last element of the list
+   * returns null if the list is empty
+   */
+  static getLast<T>(list: T[]): T | null {
     if (0 < list.length) {
       return list[list.length - 1];
     } else {

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

@@ -31,10 +31,10 @@ export class DyFM_Shared {
    * @returns remapped object list (the final obj will use the deepest keys)
    */
   static mapObjList(objList: object[], paths: string[][]): object[] {
-    let newObjList = [ ...objList ];
+    let newObjList: object[] = [ ...objList ];
 
     newObjList = newObjList.map((obj): any => {
-      const newObj = {};
+      const newObj: any = {};
 
       paths.forEach((path: string[]): void => {
         newObj[path[path.length - 1]] = this.getNestedData(obj, path);
@@ -54,7 +54,7 @@ export class DyFM_Shared {
    * @returns data from object by path
    */
   static getNestedData(parentObj: object, nestedDataKeys: string[]): any {
-    let newData = DyFM_clone(parentObj); // {...parentObj};
+    let newData: any = DyFM_clone(parentObj); // {...parentObj};
 
     nestedDataKeys.forEach((dk: string): void => {
       if (newData) {
@@ -73,11 +73,11 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static nestData(parentObj: object, nestKeys: string[], dataToSet: any): object {
-    const newData = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = DyFM_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
-      const keys = [ ...nestKeys ];
-      const nextNestKey = keys.shift();
+      const keys: string[] = [ ...nestKeys ];
+      const nextNestKey: string = keys.shift() as string;
 
       newData[nextNestKey] = this.nestData(newData[nextNestKey], keys, dataToSet);
     } else {
@@ -95,11 +95,11 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static addToNestedData(parentObj: object, nestKeys: string[], dataToAdd: any): object {
-    const newData = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = DyFM_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
-      const keys = [ ...nestKeys ];
-      const nextNestKey = keys.shift();
+      const keys: string[] = [ ...nestKeys ];
+      const nextNestKey: string = keys.shift() as string;
 
       newData[nextNestKey] = this.addToNestedData(newData[nextNestKey], keys, dataToAdd);
     } else {
@@ -117,11 +117,11 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static pushToNestedData(parentObj: object, nestKeys: string[], dataToPush: any): object {
-    const newData = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = DyFM_clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
-      const keys = [ ...nestKeys ];
-      const nextNestKey = keys.shift();
+      const keys: string[] = [ ...nestKeys ];
+      const nextNestKey: string = keys.shift() as string;
 
       newData[nextNestKey] = this.pushToNestedData(newData[nextNestKey], keys, dataToPush);
     } else {
@@ -149,11 +149,11 @@ export class DyFM_Shared {
     nestIndexes: number[], 
     dataToSet: any
   ): T {
-    const newData = DyFM_clone(parentObj); // parentObj; // {...parentObj};
+    const newData: any = DyFM_clone(parentObj); // parentObj; // {...parentObj};
 
     if (nestIndexes.length > 1) {
-      const indexes = [ ...nestIndexes ];
-      const nextLevelKey = indexes.shift();
+      const indexes: number[] = [ ...nestIndexes ];
+      const nextLevelKey: number = indexes.shift() as number;
 
       newData[nestedListKey][nextLevelKey] = this.nestRecursiveListedData(
         newData[nestedListKey][nextLevelKey], nestedListKey, indexes, dataToSet
@@ -184,7 +184,7 @@ export class DyFM_Shared {
       return 'CIRCULATION:' + location.join('.');
     }
     
-    let newData;
+    let newData: any;
 
     if (Array.isArray(data)) {
       newData = [];
@@ -195,7 +195,7 @@ export class DyFM_Shared {
     // using the utility that Object.keys will return array keys if the data is an array
     Object.keys(data).forEach((key: string): void => {
       newData[key] = this.resolveCirculation(
-        data[key], 
+        data[key as keyof typeof data], 
         [ ...location, key ], 
         [ ...objs, data ]
       );

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

@@ -6,33 +6,33 @@ import { DyFM_Log } from './log.util';
  * @returns The stack location of the constructor call
  */
 export function DyFM_getStackLocation(): string {
-  let stack: string = new Error().stack;
+  let stack: string = new Error().stack as string;
 
   // Split the stack into lines and remove the first line (Error:)
   const stackLines = stack?.split('\n')?.slice(1);
   
   // Find the line that contains the constructor call
   // It will be the FIRST line that doesn't contain 'getStackLocation'
-  let constructorLine = stackLines?.find(line => 
+  let constructorLine: string | undefined = stackLines?.find(line => 
     !line.includes('getStackLocation') && 
     !line.includes('at new')
   );
   if (!constructorLine) {
-    let constructorLine = stack?.split(' at ')?.find(line => 
+    let constructorLine: string | undefined = stack?.split(' at ')?.find(line => 
       !line.includes('getStackLocation') && 
       !line.includes('at new')
     );
 
     if (!constructorLine) {
-      DyFM_Log.warn(`No constructor line found\n${typeof stack}\n${stack?.slice(0, 100)?.split('\n') + '...'}`);
+      DyFM_Log.warn(`No constructor line found\n${typeof stack}\n${stack?.slice(0, 200)?.split('\n') + '...'}`);
       return '';
     }
   }
 
   // Remove the 'constructorLine     at ... (' and the ')'
-  constructorLine = constructorLine.split('(')[1]?.split(')')[0];
+  constructorLine = constructorLine?.split('(')[1]?.split(')')[0];
   if (!constructorLine) {
-    DyFM_Log.warn(`No constructor line found\n${typeof stack}\n${stack?.slice(0, 100)?.split('\n') + '...'}`);
+    DyFM_Log.warn(`No constructor line found\n${typeof stack}\n${stack?.slice(0, 200)?.split('\n') + '...'}`);
     return '';
   }
 

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

@@ -1,9 +1,16 @@
 
 
 
+/**
+ * String utility class
+ */
 export class DyFM_String {
 
-  /** removes \n, \r and spaces from the start and end of the string */
+  /** 
+   * Removes \n, \r and spaces from the start and end of the string
+   * @param value - The string to trim
+   * @returns The trimmed string
+   */
   static breakTrim(value: string): string {
     return value.trim().replace(/(\r\n|\n|\r)/gm, '');
   }

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

@@ -6,16 +6,51 @@ import { DyFM_RelativeDate } from '../../_enums/time/relative-date.enum';
 import { DyFM_Math } from './math/math.util';
 
 export type DyFM_T = DyFM_Time;
+/**
+ * Time utility class
+ */
 export class DyFM_Time {
 
+  /**
+   * The number of milliseconds in a second
+   */
   static readonly second = second;
+
+  /**
+   * The number of milliseconds in a minute
+   */
   static readonly minute = minute;
+
+  /**
+   * The number of milliseconds in an hour
+   */
   static readonly hour = hour;
+  
+  /**
+   * The number of milliseconds in a day
+   */
   static readonly day = day;
+
+  /**
+   * The number of milliseconds in a week
+   */
   static readonly week = week;
+
+  /**
+   * The number of milliseconds in a month
+   */
   static readonly month = month;
+
+  /**
+   * The number of milliseconds in a year
+   */
   static readonly year = year;
 
+  /**
+   * Get the age of a person
+   * @param birthDate - The birth date of the person
+   * @returns The age of the person
+   */
   static getAge(birthDate: Date | number | string): number {
     return this.getYear(+new Date() - +new Date(birthDate));
   }
@@ -143,7 +178,7 @@ export class DyFM_Time {
    */
   static getTodayOfWeek(): DyFM_DayOfWeek {
     return DyFM_DayOfWeek[
-      new Date().toLocaleString('en-us', { weekday: 'long' }).toLocaleLowerCase()
+      new Date().toLocaleString('en-us', { weekday: 'long' }).toLocaleLowerCase() as keyof typeof DyFM_DayOfWeek
     ];
   }
 
@@ -177,7 +212,7 @@ export class DyFM_Time {
    */
   static getCurrentMonth(): DyFM_Month {
     return DyFM_Month[
-      new Date().toLocaleString('en-us', { month: 'long' }).toLocaleLowerCase()
+      new Date().toLocaleString('en-us', { month: 'long' }).toLocaleLowerCase() as keyof typeof DyFM_Month
     ];
   }