@futdevpro/fsm-dynamo 1.7.3 → 1.7.6

package/src/_utils/shared.static-service.ts

@@ -33,13 +33,17 @@ export class Dynamo_Shared {
    */
   static mapObjList(objList: object[], paths: string[][]): object[] {
     let newObjList = [...objList];
-    newObjList = newObjList.map(obj => {
+
+    newObjList = newObjList.map((obj): any => {
       const newObj = {};
-      paths.forEach((path: string[]) => {
+
+      paths.forEach((path: string[]): void => {
         newObj[path[path.length - 1]] = this.getNestedData(obj, path);
       });
+
       return newObj;
     });
+
     return newObjList;
   }
 
@@ -52,11 +56,13 @@ export class Dynamo_Shared {
    */
   static getNestedData(parentObj: object, nestedDataKeys: string[]): any {
     let newData = clone(parentObj); // {...parentObj};
-    nestedDataKeys.forEach((dk: string) => {
+
+    nestedDataKeys.forEach((dk: string): void => {
       if (newData) {
         newData = newData[dk];
       }
     });
+
     return newData;
   }
 
@@ -69,13 +75,16 @@ export class Dynamo_Shared {
    */
   static nestData(parentObj: object, nestKeys: string[], dataToSet: any): object {
     const newData = clone(parentObj); // {...parentObj};
+
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
       const nextNestKey = keys.shift();
+
       newData[nextNestKey] = this.nestData(newData[nextNestKey], keys, dataToSet);
     } else {
       newData[nestKeys[0]] = dataToSet;
     }
+
     return newData;
   }
 
@@ -88,13 +97,16 @@ export class Dynamo_Shared {
    */
   static addToNestedData(parentObj: object, nestKeys: string[], dataToAdd: any): object {
     const newData = clone(parentObj); // {...parentObj};
+
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
       const nextNestKey = keys.shift();
+
       newData[nextNestKey] = this.addToNestedData(newData[nextNestKey], keys, dataToAdd);
     } else {
       newData[nestKeys[0]] += dataToAdd;
     }
+
     return newData;
   }
 
@@ -107,9 +119,11 @@ export class Dynamo_Shared {
    */
   static pushToNestedData(parentObj: object, nestKeys: string[], dataToPush: any): object {
     const newData = clone(parentObj); // {...parentObj};
+
     if (nestKeys.length > 1) {
       const keys = [...nestKeys];
       const nextNestKey = keys.shift();
+
       newData[nextNestKey] = this.pushToNestedData(newData[nextNestKey], keys, dataToPush);
     } else {
       if (Array.isArray(newData[nestKeys[0]])) {
@@ -118,6 +132,7 @@ export class Dynamo_Shared {
         newData[nestKeys[0]] = [dataToPush];
       }
     }
+
     return newData;
   }
 
@@ -129,16 +144,25 @@ export class Dynamo_Shared {
    * @param dataToSet the actual value that will be setted on location
    * @returns modified data
    */
-  static nestRecursiveListedData<T>(parentObj: T, nestedListKey: string, nestIndexes: number[], dataToSet: any): T {
+  static nestRecursiveListedData<T>(
+    parentObj: T, 
+    nestedListKey: string, 
+    nestIndexes: number[], 
+    dataToSet: any
+  ): T {
     const newData = clone(parentObj); // parentObj; // {...parentObj};
+
     if (nestIndexes.length > 1) {
       const indexes = [...nestIndexes];
       const nextLevelKey = indexes.shift();
+
       newData[nestedListKey][nextLevelKey] = this.nestRecursiveListedData(
-          newData[nestedListKey][nextLevelKey], nestedListKey, indexes, dataToSet);
+        newData[nestedListKey][nextLevelKey], nestedListKey, indexes, dataToSet
+      );
     } else {
       newData[nestedListKey][nestIndexes[0]] = dataToSet;
     }
+
     return newData;
   }
 
@@ -147,6 +171,7 @@ export class Dynamo_Shared {
     schema.__createdBy = { type: String };
     schema.__lastModified = { type: Date };
     schema.__lastModifiedBy = { type: String };
+
     return schema;
   }
 }

package/src/_utils/time.util.ts

@@ -1,49 +1,208 @@
 
 import { day, hour, month, week, year } from '../_constants/times.const';
+import { Dynamo_Month } from '../_enums';
+import { Dynamo_DayOfWeek } from '../_enums/day-of-week.enum';
+import { Dynamo_RelativeDate } from '../_enums/relative-date.enum';
 
 export type D_Time = Dynamo_Time;
 export type D_T = Dynamo_Time;
 export class Dynamo_Time {
 
-  static getAge(birthDate: Date | number | string) {
+  static getAge(birthDate: Date | number | string): number {
     return this.getYear(+new Date() - +new Date(birthDate));
   }
 
-  static getYear(date: Date | number | string) {
+  /**
+   * returns the date as a number of years
+   * @param date 
+   * @returns 
+   */
+  static getYear(date: Date | number | string): number {
     if (typeof date === 'string') {
       date = new Date(date);
     }
+    
     return (+date  / year);
   }
 
-  static getHour(date: Date | number | string) {
+  /**
+   * returns the date as a number of hours
+   * @param date 
+   * @returns 
+   */
+  static getHour(date: Date | number | string): number {
     if (typeof date === 'string') {
       date = new Date(date);
     }
+
     return (+date  / hour);
   }
 
-  static getDateByAge(age: number) {
+  /**
+   * calculates the birthdate from the age 
+   * (with current date so this wont be accurate for days or months, only years)
+   * @param date 
+   * @returns 
+   */
+  static getDateByAge(age: number): Date {
     return new Date(+new Date() - (year * age));
   }
 
+  /**
+   * returns the date x before the current date
+   * @param relativeDate 
+   * @returns 
+   */
+  static getDateByRelativeDate(relativeDate: Dynamo_RelativeDate): Date {
+    switch (relativeDate) {
+      case Dynamo_RelativeDate.lastDay:
+        return this.oneDayAgo();
+
+      case Dynamo_RelativeDate.lastWeek:
+        return this.oneWeekAgo();
+
+      case Dynamo_RelativeDate.lastMonth:
+        return this.oneMonthAgo();
+
+      case Dynamo_RelativeDate.lastYear:
+        return this.oneYearAgo();
+
+      case Dynamo_RelativeDate.last10Years:
+        return this.tenYearsAgo();
+
+      case Dynamo_RelativeDate.allTime:
+        return new Date(0);
+
+      default:
+        return new Date(0);
+    }
+  }
+
+  /**
+   * returns the date one hour ago
+   * @returns 
+   */
   static oneHourAgo(): Date {
     return new Date(+new Date() - hour);
   }
 
+  /**
+   * returns the date one day ago
+   * @returns 
+   */
   static oneDayAgo(): Date {
     return new Date(+new Date() - day);
   }
 
+  /**
+   * returns the date one week ago
+   * @returns 
+   */
   static oneWeekAgo(): Date {
     return new Date(+new Date() - week);
   }
 
+  /**
+   * returns the date one month ago
+   * @returns 
+   */
   static oneMonthAgo(): Date {
     return new Date(+new Date() - month);
   }
   
+  /**
+   * returns the date one year ago
+   * @returns 
+   */
   static oneYearAgo(): Date {
     return new Date(+new Date() - year);
   }
+  
+  /**
+   * returns the date ten years ago
+   * @returns 
+   */
+  static tenYearsAgo(): Date {
+    return new Date(+new Date() - (10 * year));
+  }
+
+  /**
+   * returns the Dynamo_DayOfWeek type of the current day
+   * @returns 
+   */
+  static getTodayOfWeek(): Dynamo_DayOfWeek {
+    return Dynamo_DayOfWeek[
+      new Date().toLocaleString('en-us', { weekday: 'long' }).toLocaleLowerCase()
+    ];
+  }
+
+  /**
+   * returns the days of the week from today to the end of the week in Dynamo_DayOfWeek format
+   * @returns 
+   */
+  static getDaysOfWeekFromToday(): Dynamo_DayOfWeek[] {
+    const today: Dynamo_DayOfWeek = this.getTodayOfWeek();
+    const daysOfWeek: Dynamo_DayOfWeek[] = Object.values(Dynamo_DayOfWeek);
+    const todayIndex: number = daysOfWeek.indexOf(today);
+
+    return daysOfWeek.slice(todayIndex).concat(daysOfWeek.slice(0, todayIndex));
+  }
+
+  /**
+   * returns the days of the week to today to the end of the week in Dynamo_DayOfWeek format
+   * @returns 
+   */
+  static getDaysOfWeekToToday(): Dynamo_DayOfWeek[] {
+    const today: Dynamo_DayOfWeek = this.getTodayOfWeek();
+    const daysOfWeek: Dynamo_DayOfWeek[] = Object.values(Dynamo_DayOfWeek);
+    const todayIndex: number = daysOfWeek.indexOf(today);
+
+    return daysOfWeek.slice(0, todayIndex).reverse().concat(daysOfWeek.slice(todayIndex).reverse());
+  }
+
+  /**
+   * returns the Dynamo_Month type of the current month
+   * @returns 
+   */
+  static getCurrentMonth(): Dynamo_Month {
+    return Dynamo_Month[
+      new Date().toLocaleString('en-us', { month: 'long' }).toLocaleLowerCase()
+    ];
+  }
+
+  /**
+   * returns the number of days in the month
+   * @param inYear this value is important for february if you want to know if it is a leap year
+   * @returns 
+   */
+  static getMonthLength(month: Dynamo_Month, inYear?: number): number {
+    switch (month) {
+      case Dynamo_Month.january:
+      case Dynamo_Month.march:
+      case Dynamo_Month.may:
+      case Dynamo_Month.june:
+      case Dynamo_Month.august:
+      case Dynamo_Month.october:
+        return 31;
+
+      case Dynamo_Month.april:
+      case Dynamo_Month.july:
+      case Dynamo_Month.september:
+      case Dynamo_Month.november:
+      case Dynamo_Month.december:
+        return 30;
+
+      case Dynamo_Month.february:
+        return this.isLeapYear(inYear ?? new Date().getFullYear()) ? 29 : 28;
+    }
+  }
+
+  /**
+   * returns year is leap or not
+   * @param year 
+   * @returns 
+   */
+  static isLeapYear(year: number): boolean {
+    return year % 4 === 0;
+  }
 }

package/src/_utils/trigonometry.util.ts

@@ -15,6 +15,7 @@ export class Dynamo_Trigonometry {
    */
   static getClamp(c: number, angle?: number): number {
     angle = angle !== undefined ? angle : 45;
+
     return Math.sin(this.angleToRadians(angle)) * c;
   }
 
@@ -27,8 +28,13 @@ export class Dynamo_Trigonometry {
    */
   static getClampByClampAndHypotenuse(a: number, c: number): number {
     if (a > c) {
-      throw { errorMessage: `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` };
+
+      throw { 
+        errorMessage: 
+          `getClampByClampAndHypotenuse error hypotenuse is smaller than clamp (a:${a} > c:${c})` 
+      };
     }
+
     return Math.sqrt((c * c) - (a * a));
   }
 
@@ -43,6 +49,7 @@ export class Dynamo_Trigonometry {
    */
   static getHypotenuse(a: number, b?: number): number {
     b = b !== undefined ? b : a;
+    
     return Math.sqrt((a * a) + (b * b));
   }
 

package/src/_utils/type-cloning-facility.util.ts

@@ -0,0 +1,121 @@
+
+export type Dynamo_TCF = Dynamo_TypeCloningFacility;
+export type D_TypeCloningFacility = Dynamo_TypeCloningFacility;
+export type D_TCF = Dynamo_TCF;
+
+/** 
+ * 
+ * This functions should be able to clone any object, 
+ * even if it contains circular references.
+ * 
+ * if the object has a clone() function, it will be used.
+ * if the object has any getter or setter, it will be ignored, 
+ * therefore it should have a clone() function.
+ * 
+ * WARNING: this function will clone all connected objects!
+ * 
+ * */
+export class Dynamo_TypeCloningFacility {
+
+  static clone<T>(
+    object: T, 
+    skip: string[] = [], 
+    affectedObjects: ObjectCollector[] = [],
+    debug: boolean = false
+  ): T {
+    const result: T = {} as T;
+
+    for (const key in object) {
+      if (debug) {
+        console.log('clone DEBUG; key:', key);
+      }
+
+      if (typeof object === 'object'/* object.hasOwnProperty(key) */) {
+        const type = typeof object[key];
+
+        if (skip.includes(key)) {
+          continue;
+
+        } else if (type === 'object') {
+          const alreadyAffected = affectedObjects?.find(
+            (affectedObject): boolean => affectedObject.id === object[key]
+          );
+
+          if (alreadyAffected) {
+            result[key] = alreadyAffected.clonedObject;
+            
+          } else {
+            const newAffectedObject: ObjectCollector = {
+              id: object[key]
+            };
+
+            affectedObjects.push(newAffectedObject);
+            
+            if (Array.isArray(object[key])) {
+              newAffectedObject.clonedObject = this.cloneArray(
+                object[key] as unknown[], 
+                skip, 
+                affectedObjects,
+                debug
+              );
+
+            } else if (
+              (object[key] as any)?.clone && 
+              typeof (object[key] as any)?.clone === 'function'
+            ) {
+              newAffectedObject.clonedObject = (object[key] as any).clone();
+
+            } else {
+              newAffectedObject.clonedObject = this.clone(
+                object[key], 
+                skip, 
+                affectedObjects,
+                debug
+              );
+            }
+
+            result[key] = newAffectedObject.clonedObject;
+          }
+        } else {
+          result[key] = object[key];
+        }
+      }
+    }
+
+    return result;
+  }
+
+  static cloneArray<T>(
+    array: T[],
+    skip: string[] = [], 
+    affectedObjects: ObjectCollector[] = [],
+    debug: boolean = false
+  ): T[] {
+    const result: T[] = [];
+
+    array.forEach((element, index): void => {
+      if (debug) {
+        console.log('cloneArrayDEBUG; index', index);
+      }
+
+      if (typeof element === 'object') {
+        result.push(this.clone(element, skip, affectedObjects, debug));
+
+      } else {
+        result.push(element);
+      }
+    });
+
+    return result;
+  }
+
+  storeCirculation // TODO stringifyable -------------------------------------------------------------------------------------------------------------------------------------------
+
+  restoreCirculation // TODO stringified -------------------------------------------------------------------------------------------------------------------------------------------
+}
+
+interface ObjectCollector {
+  id;
+  clonedObject?;
+}
+

package/src/_utils/utilities.util.ts

@@ -1,9 +1,18 @@
 
+const defaultErrorMsg = ' failed. ' +
+'\nThis might be happening becouse the object you trying to clone, ' +
+'containes object hooks for its own objects, therefore its creating an object loop. ' +
+'See further information in the detailed error:\n\n';
+
 export function clone<T>(object: T): T {
   try {
     return object ? JSON.parse(JSON.stringify(object)) as T : object;
   } catch (error) {
-    console.error('clone() failed. This might be happening becouse the object you trying to clone, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    console.error(
+      'clone()' + defaultErrorMsg,
+      error
+    );
+
     throw error;
   }
 }
@@ -12,12 +21,18 @@ export const copy = clone;
 export function surfaceClone<T>(object: T): T {
   try {
     const result = {};
-    Object.keys(object).forEach((key: string) => {
+
+    Object.keys(object).forEach((key: string): void => {
       result[key] = object[key];
     });
+
     return result as T;
   } catch (error) {
-    console.error('clone() failed. This might be happening becouse the object you trying to clone, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    console.error(
+      'surfaceClone()' + defaultErrorMsg,
+      error
+    );
+
     throw error;
   }
 }
@@ -27,7 +42,11 @@ export function sameObjects<T>(objA: T, objB: T): boolean {
   try {
     return JSON.stringify(objA) === JSON.stringify(objB);
   } catch (error) {
-    console.error('sameObjects() failed. This might be happening becouse the object you trying to check, containes object hooks for its own objects, therefore its creating an object loop. See further information in the detailed error:');
+    console.error(
+      'sameObjects()' + defaultErrorMsg,
+      error
+    );
+
     throw error;
   }
 }
@@ -46,11 +65,13 @@ export function setExisitngValuesOnly(setOn: any, setTo: any): void {
 }
 
 export function delay(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms) );
+  return new Promise((resolve): any => setTimeout(resolve, ms));
 }
 export const sleep = delay;
 export const wait = delay;
 
+export type Dynamo_SortDirection = 0 | 1 | -1
+
 /**
  * You might be use getSortForTrueFn instead for a shorter expression
  * 
@@ -62,8 +83,9 @@ export const wait = delay;
  * @example 
  * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
  */
-export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): 0 | 1 | -1 {
+export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): Dynamo_SortDirection {
   const isA = check(a);
+
   return isA === check(b) ? 0 : isA ? -1 : 1;
 }
 
@@ -75,15 +97,18 @@ export function sortForTrue<T>(a: T, b: T, check: (a: T) => boolean): 0 | 1 | -1
  * @example
  * codes.sort(getSortForTrueFn((c: Code) => c.haveImg));
  */
-export function getSortForTrueFn<T>(checkFor: (a: T) => boolean): (a: T, b: T) => 0 | 1 | -1 {
-  return (a: T, b: T) => sortForTrue<T>(a, b, checkFor);
+export function getSortForTrueFn<T>(
+  checkFor: (a: T) => boolean): (a: T, b: T) => Dynamo_SortDirection {
+  return (a: T, b: T): Dynamo_SortDirection => sortForTrue<T>(a, b, checkFor);
 }
 
 export function JSONListify<T>(JSONList): T[] {
   const result: T[] = [];
+
   for (let i = 0; JSONList[i]; i++) {
     result.push(JSONList[i] as T);
   }
+
   return result; 
 }