@futdevpro/fsm-dynamo 1.9.39 → 1.9.41

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

@@ -50,11 +50,11 @@ export class DyFM_Array {
   }
 
   static last<T>(array: T[]): T {
-    return array.length ? array[array.length - 1] : null;
+    return array?.length ? array[array.length - 1] : null;
   }
 
   static lastString(array: string): string {
-    return array.length ? array[array.length - 1] : null;
+    return array?.length ? array[array.length - 1] : null;
   }
 
   static remove<T>(array: T[], element: T): T[] {
@@ -104,7 +104,7 @@ export class DyFM_Array {
       pageSize,
       total: array.length,
       totalPageCount: Math.ceil(array.length / pageSize),
-      items: this.page(array, pageIndex, pageSize)
+      items: this.page(array, pageIndex, pageSize),
     };
   }
 
@@ -137,7 +137,7 @@ export class DyFM_Array {
     }
   }
 
-  getRoundListOutboundIndex<T>(array: T[], index: number): T {
+  static getRoundListOutboundIndex<T>(array: T[], index: number): T {
     try {
       while (array.length <= index) {
         index -= array.length;
@@ -159,7 +159,71 @@ export class DyFM_Array {
     }
   }
 
-  findDuplicates
+  static stringListHasMultiplications(stringList: string[]): boolean {
+    return stringList.some((str: string, index: number): boolean => {
+      return stringList.findIndex((strItem: string): boolean => strItem === str) !== index;
+    });
+  }
+
+  static filterStringMultiplications(stringList: string[]): string[] {
+    return stringList.filter((str: string, index: number): boolean => {
+      return stringList.findIndex((strItem: string): boolean => strItem === str) !== index;
+    });
+  }
+
+  static gatherStringMultiplications(stringList: string[]): string[][] {
+    const multiplications = [];
+
+    stringList.forEach((str: string, index: number): void => {
+      if (multiplications.find(
+        (multiplication: string[]): boolean => multiplication.includes(str))
+      ) {
+        return;
+      }
+
+      const sameStrings = stringList.filter((strItem: string): boolean => strItem === str);
+
+      if (sameStrings.length > 1) {
+        multiplications.push(sameStrings);
+      }
+    });
+
+    return multiplications;
+  }
+
+  static haveMultiplications<T extends object>(dataList: T[], byKey: string = '_id'): boolean {
+    return dataList.some((data: T, index: number): boolean => {
+      return dataList.findIndex(
+        (listItem: T): boolean => listItem[byKey] === data[byKey]
+      ) !== index;
+    });
+  }
+
+  static filterMultiplications<T extends object>(dataList: T[], byKey: string = '_id'): T[] {
+    return dataList.filter((data: T, index: number): boolean => {
+      return dataList.findIndex(
+        (listItem: T): boolean => listItem[byKey] === data[byKey]
+      ) !== index; 
+    });
+  }
+
+  static gatherMultiplications<T extends object>(dataList: T[], byKey: string = '_id'): T[][] {
+    const multiplications = [];
+
+    dataList.forEach((data: T, index: number): void => {
+      if (multiplications.find((multiplication: T[]): boolean => multiplication.includes(data))) {
+        return;
+      }
+
+      const sameData = dataList.filter((listItem: T): boolean => listItem[byKey] === data[byKey]);
+
+      if (sameData.length > 1) {
+        multiplications.push(sameData);
+      }
+    });
+
+    return multiplications;
+  } 
 
 }
 

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

@@ -200,11 +200,11 @@ export class DyFM_Log {
   static readonly H_success = DyFM_Log.highlightedSuccess;
 
   // eslint-disable-next-line max-len
-  private static h_solid: string =  '|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||';
+  private static readonly h_solid: string =  '|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||';
   // eslint-disable-next-line max-len
-  private static h_before: string = '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\';
+  private static readonly h_before: string = '\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\';
   // eslint-disable-next-line max-len
-  private static h_after: string =  '/////////////////////////////////////////////////////////////////////////////';
+  private static readonly h_after: string =  '/////////////////////////////////////////////////////////////////////////////';
 
   static removeLogStyles(message: string): string {
     for (const styleKey of Object(DyFM_LogStyle)) {

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

@@ -285,6 +285,10 @@ export class DyFM_Vector2_Util implements DyFM_Vector2 {
   }
   getVector2 = this.get;
   toVector2 = this.get;
+
+  static clone(v: DyFM_Vector2): DyFM_Vector2 {
+    return { x: v.x, y: v.y };
+  }
 }
 
 

package/src/_collections/utils/{shared.static-service.ts → shared.util.ts}

@@ -140,7 +140,7 @@ export class DyFM_Shared {
    * @param newData the object that that is needed to be updated
    * @param nestedListKey the location of nested dataList
    * @param nestIndexes path to the subject ect.: xData.listKey[1].listKey[4].listKey[0] will be [1, 4, 0]
-   * @param dataToSet the actual value that will be setted on location
+   * @param dataToSet the actual value that will be seted on location
    * @returns modified data
    */
   static nestRecursiveListedData<T>(
@@ -165,35 +165,82 @@ export class DyFM_Shared {
     return newData;
   }
 
+  static readonly removeCirculation = this.resolveCirculation;
   /**
+   * THIS STILL NOT WORKING AS IT SHOULD
+   * 
    * recursive function that returns mutated data structure, 
    * with locations at which circular references are found
    */
   static resolveCirculation<T>(
     data: T, 
-    location: string[] = [ ('ROOT_' + data?.constructor?.name) ], 
-    objs: any[] = [ data ]
+    location: string[] = [ ('ROOT;' + data?.constructor?.name) ], 
+    objs: any[] = [],
+    /* arrs: any[] = [] */
   ): any {
-    if (!data || !Array.isArray(data) || typeof data !== 'object') {
+    if (!data || typeof data !== 'object') {
       return data;
+    } else if (objs.includes(data)) {
+      return 'CIRCULATION:' + location.join('.');
     }
     
-    const newData = {};
-    
+    let newData;
+
+    if (Array.isArray(data)) {
+      newData = [];
+    } else {
+      newData = {};
+    }
+
+    // using the utility that Object.keys will return array keys if the data is an array
     Object.keys(data).forEach((key: string): void => {
-      if (typeof data[key] === 'object' || Array.isArray(data[key])) {
-        if (objs.includes(data[key])) {
-          newData[key] = 'CIRCULATION:' + location.join('.');
-        } else {
-          objs.push(data[key]);
-          newData[key] = this.resolveCirculation(data[key], [ ...location, key ], objs);
-        }
-      } else {
-        newData[key] = data[key];
-      }
+      newData[key] = this.resolveCirculation(
+        data[key], 
+        [ ...location, key ], 
+        [ ...objs, data ]
+      );
     });
 
     return newData;
   }
 
+
+  /**
+   * looks for circular references in object
+   * returns duplicated object's all location paths and the object itself
+   *  
+   *  { 
+   *    object: any,
+   *    pathsOfAllDuplications: string[],
+   *  }[]
+   * 
+   * paths are in a single string, separated by '.'
+   */
+  static findCirculations(
+    data: any, 
+    location: string[] = [ ('ROOT;' + data?.constructor?.name) ], 
+    objs: any[] = [],
+    duplications: { object: any, pathsOfAllDuplications: string[] }[] = []
+  ): { object: any, pathsOfAllDuplications: string[] }[] {
+    if (!data || typeof data !== 'object') {
+      return duplications;
+    } else if (objs.includes(data)) {
+      duplications.push({
+        object: data,
+        pathsOfAllDuplications: location,
+      });
+    }
+
+    Object.keys(data).forEach((key: string): void => {
+      this.findCirculations(
+        data[key], 
+        [ ...location, key ], 
+        [ ...objs, data ],
+        duplications
+      );
+    });
+
+    return duplications;
+  }
+
 }

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

@@ -3,6 +3,7 @@ import { day, hour, minute, month, second, week, year } from '../constants/times
 import { DyFM_Month } from '../../_enums/time/month.enum';
 import { DyFM_DayOfWeek } from '../../_enums/time/day-of-week.enum';
 import { DyFM_RelativeDate } from '../../_enums/time/relative-date.enum';
+import { DyFM_Math } from './math/math.util';
 
 export type DyFM_T = DyFM_Time;
 export class DyFM_Time {
@@ -216,6 +217,28 @@ export class DyFM_Time {
     return year % 4 === 0;
   }
 
+  static getDurationString(duration: number): string {
+    if (duration === 0) {
+      return '0ms';
+    } else if (duration < second) {
+      return `${duration}ms`;
+    } else if (duration < minute) {
+      return `${DyFM_Math.round(duration / second)}s ${duration % second}ms`;
+    } else if (duration < hour) {
+      return `${DyFM_Math.round(duration / minute)}m ${DyFM_Math.round(duration % minute)}s`;
+    } else if (duration < day) {
+      return `${DyFM_Math.round(duration / hour)}h ${DyFM_Math.round(duration % hour)}m`;
+    } else if (duration < week) {
+      return `${DyFM_Math.round(duration / day)}d ${DyFM_Math.round(duration % day)}h`;
+    } else if (duration < month) {
+      return `${DyFM_Math.round(duration / week)}w ${DyFM_Math.round(duration % week)}d`;
+    } else if (duration < year) {
+      return `${DyFM_Math.round(duration / month)}m ${DyFM_Math.round(duration % month)}w`;
+    } else {
+      return `${DyFM_Math.round(duration / year)}y ${DyFM_Math.round(duration % year)}m`;
+    }
+  }
+
   static getTimeInShortestString(time: number): string {
     if (time % year === 0) {
       return `${time / year}y`;

package/src/_models/control-models/error.control-model.spec.ts

@@ -4,6 +4,14 @@ import { DyFM_error_defaults } from '../../_collections/constants/error-defaults
 import { DyFM_Log } from '../../_collections/utils/log.util';
 import { DyFM_Error } from './error.control-model';
 
+function testFormatter(any: any): any {
+  if (any instanceof Error) {
+    return any;
+  } else {
+    return `\n${JSON.stringify(any, null, 2)}\n`;
+  }
+}
+
 describe('DyFM_Error;', (): void => {
   let error_base: Error;
   let error_0: DyFM_Error;
@@ -16,7 +24,7 @@ describe('DyFM_Error;', (): void => {
   const message_base: string = '-TEST ERROR: something failed!-';
   const message_1: string = 'TEST ERROR MSG (1)';
   const message_2: string = 'TEST ERROR MSG (2)';
-  const message_selfDefined: string = 'error.control-model.spec.js:82:29';
+  const message_selfDefined: string = 'error.control-model.spec.js:89:29';
   
   const errorCode_0: string = 'ASD-ASD-001';
   const errorCode_1: string = 'ASD-ASD-002';
@@ -71,9 +79,9 @@ describe('DyFM_Error;', (): void => {
       ...error_stack_1,
     } as DyFM_Error;
     error_stack_withoutSubErrors_1.errors.forEach((error: DyFM_Error): any => {
-      const subError = { ...error };
+      const subError = { ...error } as DyFM_Error;
 
-      delete (subError as DyFM_Error).errors;
+      delete subError.errors;
 
       return subError;
     });
@@ -90,12 +98,13 @@ describe('DyFM_Error;', (): void => {
     error_stack_withoutSubErrors_2 = {
       ...error_stack_2,
     } as DyFM_Error;
-    error_stack_withoutSubErrors_2.errors.map((error: DyFM_Error): any => {
-      const subError = { ...error };
 
-      delete (subError as DyFM_Error).errors;
+    error_stack_withoutSubErrors_2.errors = error_stack_withoutSubErrors_2.errors.map(
+      (error: DyFM_Error): any => ({ ...error })
+    );
 
-      return subError;
+    error_stack_withoutSubErrors_2.errors.forEach((subError: DyFM_Error): any => {
+      delete subError.errors;
     });
 
     error_selfDefined = new DyFM_Error();
@@ -301,19 +310,25 @@ describe('DyFM_Error;', (): void => {
 
   describe('should have proper error;', (): void => {
     it('on error_0', (): void => {
-      expect(error_0.error).toBe(error_base);
+      expect(testFormatter(error_0.error)).toBe(
+        testFormatter(error_base)
+      );
     });
 
     it('on error_stack_1', (): void => {
-      expect(error_stack_1.error).toBe(error_base);
+      expect(testFormatter(error_stack_1.error)).toBe(
+        testFormatter(error_base)
+      );
     });
 
     it('on error_stack_2', (): void => {
-      expect(error_stack_2.error).toBe(error_base);
+      expect(testFormatter(error_stack_2.error)).toBe(
+        testFormatter(error_base)
+      );
     });
 
     it('on self defined error', (): void => {
-      expect(error_selfDefined.error).toBeDefined();
+      expect(testFormatter(error_selfDefined.error)).toBeDefined();
     });
   });
 
@@ -323,11 +338,28 @@ describe('DyFM_Error;', (): void => {
     });
 
     it('on error_stack_1', (): void => {
-      expect(error_stack_1.errors).toEqual([ error_base, error_0 ]);
+      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
+
+      delete error_0_withoutSubErrors.errors;
+      delete error_0_withoutSubErrors.additionalContent;
+      
+      expect(testFormatter(error_stack_1.errors)).toEqual(
+        testFormatter([ error_base, error_0_withoutSubErrors ])
+      );
     });
 
     it('on error_stack_2', (): void => {
-      expect(error_stack_2.errors).toEqual([ error_base, error_0, error_stack_1 ]);
+      const error_0_withoutSubErrors = { ...error_0 } as DyFM_Error;
+      const error_stack_1_withoutSubErrors = { ...error_stack_1 } as DyFM_Error;
+
+      delete error_0_withoutSubErrors.errors;
+      delete error_0_withoutSubErrors.additionalContent;
+      delete error_stack_1_withoutSubErrors.errors;
+      delete error_stack_1_withoutSubErrors.additionalContent;
+
+      expect(testFormatter(error_stack_2.errors)).toEqual(
+        testFormatter([ error_base, error_0_withoutSubErrors, error_stack_1_withoutSubErrors ])
+      );
     });
 
     it('on self defined error', (): void => {