@futdevpro/fsm-dynamo 1.11.23 → 1.11.25

package/src/_collections/utils/{shared.util.ts → object.util.ts}

@@ -1,8 +1,14 @@
 
 import { DyFM_Log } from './log.util';
-import { DyFM_clone, DyFM_sameObjects } from './utilities.util';
+import { DyFM_JsonErrorHelper } from './json-error-helper.util';
 
-export class DyFM_Shared {
+export class DyFM_Object {
+
+  static readonly defaultErrorMsg = 
+    ' failed. ' +
+    '\nThis might be happening because the object you trying to clone, ' +
+    'contains object hooks for its own objects, therefore its creating an object loop. ' +
+    'See further information in the detailed error:\n\n';
 
   /**
    * returns remapped object list by path list
@@ -55,7 +61,7 @@ export class DyFM_Shared {
    * @returns data from object by path
    */
   static getNestedData(parentObj: object, nestedDataKeys: string[]): any {
-    let newData: any = DyFM_clone(parentObj); // {...parentObj};
+    let newData: any = this.clone(parentObj); // {...parentObj};
 
     nestedDataKeys.forEach((dk: string): void => {
       if (newData) {
@@ -74,7 +80,7 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static nestData(parentObj: object, nestKeys: string[], dataToSet: any): object {
-    const newData: any = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = this.clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys: string[] = [ ...nestKeys ];
@@ -96,7 +102,7 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static addToNestedData(parentObj: object, nestKeys: string[], dataToAdd: any): object {
-    const newData: any = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = this.clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys: string[] = [ ...nestKeys ];
@@ -118,7 +124,7 @@ export class DyFM_Shared {
    * @returns modified data
    */
   static pushToNestedData(parentObj: object, nestKeys: string[], dataToPush: any): object {
-    const newData: any = DyFM_clone(parentObj); // {...parentObj};
+    const newData: any = this.clone(parentObj); // {...parentObj};
 
     if (nestKeys.length > 1) {
       const keys: string[] = [ ...nestKeys ];
@@ -150,7 +156,7 @@ export class DyFM_Shared {
     nestIndexes: number[], 
     dataToSet: any
   ): T {
-    const newData: any = DyFM_clone(parentObj); // parentObj; // {...parentObj};
+    const newData: any = this.clone(parentObj); // parentObj; // {...parentObj};
 
     if (nestIndexes.length > 1) {
       const indexes: number[] = [ ...nestIndexes ];
@@ -292,7 +298,7 @@ export class DyFM_Shared {
           source[key].forEach(item => {
             if (
               !target[key].includes(item) &&
-              !target[key].some(targetItem => DyFM_sameObjects(item, targetItem))
+              !target[key].some(targetItem => this.sameObjects(item, targetItem))
             ) {
               target[key].push(item);
             }
@@ -375,6 +381,7 @@ export class DyFM_Shared {
   /**
    * parses the JSON, if it fails, it throws an error
    * (also will extract the JSON from "```json ... ```" wrapper)
+   * Uses enhanced error reporting with line context
    */
   static failableSafeParseJSON<T = any>(textedJSON: string): T {
     if (!textedJSON) {
@@ -382,16 +389,264 @@ export class DyFM_Shared {
     }
 
     const match = textedJSON.match(/```json(.*)```/s);
-    textedJSON = textedJSON.replaceAll('\n', '');
+    const cleanedTextedJSON = textedJSON.replaceAll('\n', '');
 
     if (match) {
-      return JSON.parse(match[1].replaceAll('\n', ''));
+      return DyFM_JsonErrorHelper.parseJsonWithEnhancedError(match[1].replaceAll('\n', ''));
     } else {
-      return JSON.parse(
-        textedJSON.replaceAll('```json', '').replaceAll('```', '')
+      return DyFM_JsonErrorHelper.parseJsonWithEnhancedError(
+        cleanedTextedJSON.replaceAll('```json', '').replaceAll('```', '')
       );
     }
   }
-}
 
-export type DyFM_Object = DyFM_Shared;
+
+
+
+
+
+
+
+
+
+
+
+
+  
+  /**
+   * Clone an object
+   * @param object - The object to clone
+   * @returns The cloned object
+   */
+  static clone<T>(object: T): T {
+    try {
+      return object ? JSON.parse(JSON.stringify(object)) as T : object;
+    } catch (error) {
+      DyFM_Log.error(
+        'clone()' + this.defaultErrorMsg,
+        error
+      );
+
+      throw error;
+    }
+  }
+  static readonly copy: typeof this.clone = this.clone;
+
+  /**
+   * Surface clone an object
+   * @param object - The object to surface clone
+   * @returns The surface cloned object
+   */
+  static surfaceClone<T extends Record<string, any>>(object: T): T {
+    try {
+      const result: Record<string, any> = {};
+
+      Object.keys(object).forEach((key: string): void => {
+        result[key] = object[key];
+      });
+
+      return result as T;
+    } catch (error) {
+      DyFM_Log.error(
+        'surfaceClone()' + this.defaultErrorMsg,
+        error
+      );
+
+      throw error;
+    }
+  }
+  static readonly surfaceCopy: typeof this.surfaceClone = this.surfaceClone;
+
+  /**
+   * Deep clone an object
+   * @param object - The object to deep clone
+   * @returns The deep cloned object
+   */
+  static deepClone<T extends Record<string, any>>(object: T): T {
+    try {
+      const result: Record<string, any> = {};
+      
+      Object.keys(object).forEach((key: string): void => {
+        if (typeof object[key] === 'object') {
+          result[key] = this.deepClone(object[key]);
+        } else if (Array.isArray(object[key])) {
+          result[key] = object[key].map((item: any): any => this.deepClone(item));
+        } else {
+          result[key] = object[key];
+        }
+      });
+
+      return result as T;
+    } catch (error) {
+      DyFM_Log.error(
+        'deepClone()' + this.defaultErrorMsg,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * A simple object comparison function that uses JSON.stringify() to compare objects.
+   * 
+   * We experienced that sameObjects() function is not working properly for cases when 
+   * deleting a key from the objects (to prevent strict results).
+   * So, we created orderedSameObject() function to prevent that issue.
+   * But be aware that, that function is not as fast as sameObjects() function.
+   */
+  static sameObjects<T>(objA: T, objB: T): boolean {
+    try {
+      return JSON.stringify(objA) === JSON.stringify(objB);
+    } catch (error) {
+      DyFM_Log.error(
+        'sameObjects()' + this.defaultErrorMsg,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * We experienced that sameObjects() function is not working properly for cases when 
+   * deleting a key from the objects (to prevent strict results).
+   * 
+   * This function is created to prevent that issue.
+   * But be aware that this function is not as fast as sameObjects() function.
+   */
+  static orderedSameObject<T>(objA: T, objB: T): boolean {
+    try {
+      if (
+        typeof objA !== 'object' || 
+        typeof objB !== 'object' ||
+        Array.isArray(objA) ||
+        Array.isArray(objB) ||
+        objA === null ||
+        objB === null ||
+        objA === undefined ||
+        objB === undefined
+      ) {
+        return JSON.stringify(objA) === JSON.stringify(objB);
+      }
+
+      const keysA = Object.keys(objA);
+      const keysB = Object.keys(objB);
+
+      if (keysA.length !== keysB.length) {
+        return false;
+      }
+
+      keysA.sort();
+      keysB.sort();
+
+      for (let i = 0; i < keysA.length; i++) {
+        if (JSON.stringify(keysA[i]) !== JSON.stringify(keysB[i])) {
+          return false;
+        }
+      }
+
+      return true;
+    } catch (error) {
+      /* try {
+        return DyFM_Object.orderedSameObject2(objA, objB);
+      } catch (error) { */
+        DyFM_Log.error(
+          'orderedSameObject()' + this.defaultErrorMsg,
+          error
+        );
+
+        throw error;
+      /* } */
+    }
+  }
+
+  /**
+   * We experienced that sameObjects() function is not working properly for cases when 
+   * deleting a key from the objects (to prevent strict results).
+   * 
+   * This function is created to prevent that issue.
+   * But be aware that this function is not as fast as sameObjects() function.
+   */
+  static orderedSameObject2<T>(objA: T, objB: T): boolean {
+    try {
+      console.log('using orderedSameObject2');
+      
+      if (
+        typeof objA !== 'object' || 
+        typeof objB !== 'object' ||
+        Array.isArray(objA) ||
+        Array.isArray(objB) ||
+        objA === null ||
+        objB === null ||
+        objA === undefined ||
+        objB === undefined
+      ) {
+        return JSON.stringify(objA) === JSON.stringify(objB);
+      } 
+      
+      return JSON.stringify(
+        objA, 
+        Object.keys(objA).sort()
+      ) === JSON.stringify(
+        objB, 
+        Object.keys(objB).sort()
+      );
+    } catch (error) {
+      DyFM_Log.error(
+        'sameObjects()' + this.defaultErrorMsg,
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  /**
+   * compares the surface of two objects
+   * @param objA 
+   * @param objB 
+   * @returns 
+   */
+  static sameObjectSurface<T>(objA: T, objB: T): boolean {
+    let result = true;
+
+    for (const key in objA) {
+      if (objA[key] !== objB[key]) {
+        result = false;
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * sets values if its existing on To, even if its null (but if undefined)
+   * @param setOn
+   * @param setTo 
+   */
+  static setExistingValuesOnly(setOn: any, setTo: any): void {
+    for (const key in setTo) {
+      if (setTo[key] != undefined) {
+        setOn[key] = setTo[key];
+      }
+    }
+  }
+
+  /**
+   * converts a JSONList to an array
+   * @param JSONList 
+   * @returns 
+   */
+  static JSONListify<T>(JSONList: any): T[] {
+    const result: T[] = [];
+
+    for (let i = 0; JSONList[i]; i++) {
+      result.push(JSONList[i]);
+    }
+
+    return result; 
+  }
+
+}

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

@@ -1,377 +1,3 @@
-import { Observable } from 'rxjs';
-
-import { DyFM_Log } from './log.util';
-
-const defaultErrorMsg = 
-  ' failed. ' +
-  '\nThis might be happening because the object you trying to clone, ' +
-  'contains object hooks for its own objects, therefore its creating an object loop. ' +
-  'See further information in the detailed error:\n\n';
-
-/**
- * Clone an object
- * @param object - The object to clone
- * @returns The cloned object
- */
-export function DyFM_clone<T>(object: T): T {
-  try {
-    return object ? JSON.parse(JSON.stringify(object)) as T : object;
-  } catch (error) {
-    DyFM_Log.error(
-      'clone()' + defaultErrorMsg,
-      error
-    );
-
-    throw error;
-  }
-}
-export const DyFM_copy = DyFM_clone;
-
-/**
- * Surface clone an object
- * @param object - The object to surface clone
- * @returns The surface cloned object
- */
-export function DyFM_surfaceClone<T extends Record<string, any>>(object: T): T {
-  try {
-    const result: Record<string, any> = {};
-
-    Object.keys(object).forEach((key: string): void => {
-      result[key] = object[key];
-    });
-
-    return result as T;
-  } catch (error) {
-    DyFM_Log.error(
-      'surfaceClone()' + defaultErrorMsg,
-      error
-    );
-
-    throw error;
-  }
-}
-export const DyFM_surfaceCopy = DyFM_surfaceClone;
-
-/**
- * Deep clone an object
- * @param object - The object to deep clone
- * @returns The deep cloned object
- */
-export function DyFM_deepClone<T extends Record<string, any>>(object: T): T {
-  try {
-    const result: Record<string, any> = {};
-    
-    Object.keys(object).forEach((key: string): void => {
-      if (typeof object[key] === 'object') {
-        result[key] = DyFM_deepClone(object[key]);
-      } else if (Array.isArray(object[key])) {
-        result[key] = object[key].map((item: any): any => DyFM_deepClone(item));
-      } else {
-        result[key] = object[key];
-      }
-    });
-
-    return result as T;
-  } catch (error) {
-    DyFM_Log.error(
-      'deepClone()' + defaultErrorMsg,
-      error
-    );
-
-    throw error;
-  }
-}
-
-/**
- * A simple object comparison function that uses JSON.stringify() to compare objects.
- * 
- * We experienced that sameObjects() function is not working properly for cases when 
- * deleting a key from the objects (to prevent strict results).
- * So, we created orderedSameObject() function to prevent that issue.
- * But be aware that, that function is not as fast as sameObjects() function.
- */
-export function DyFM_sameObjects<T>(objA: T, objB: T): boolean {
-  try {
-    return JSON.stringify(objA) === JSON.stringify(objB);
-  } catch (error) {
-    DyFM_Log.error(
-      'sameObjects()' + defaultErrorMsg,
-      error
-    );
-
-    throw error;
-  }
-}
-
-/**
- * We experienced that sameObjects() function is not working properly for cases when 
- * deleting a key from the objects (to prevent strict results).
- * 
- * This function is created to prevent that issue.
- * But be aware that this function is not as fast as sameObjects() function.
- */
-export function DyFM_orderedSameObject<T>(objA: T, objB: T): boolean {
-  try {
-    if (
-      typeof objA !== 'object' || 
-      typeof objB !== 'object' ||
-      Array.isArray(objA) ||
-      Array.isArray(objB) ||
-      objA === null ||
-      objB === null ||
-      objA === undefined ||
-      objB === undefined
-    ) {
-      return JSON.stringify(objA) === JSON.stringify(objB);
-    }
-
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-
-    if (keysA.length !== keysB.length) {
-      return false;
-    }
-
-    keysA.sort();
-    keysB.sort();
-
-    for (let i = 0; i < keysA.length; i++) {
-      if (JSON.stringify(keysA[i]) !== JSON.stringify(keysB[i])) {
-        return false;
-      }
-    }
-
-    return true;
-  } catch (error) {
-    /* try {
-      return DyFM_orderedSameObject2(objA, objB);
-    } catch (error) { */
-      DyFM_Log.error(
-        'orderedSameObject()' + defaultErrorMsg,
-        error
-      );
-
-      throw error;
-    /* } */
-  }
-}
-
-/**
- * We experienced that sameObjects() function is not working properly for cases when 
- * deleting a key from the objects (to prevent strict results).
- * 
- * This function is created to prevent that issue.
- * But be aware that this function is not as fast as sameObjects() function.
- */
-export function DyFM_orderedSameObject2<T>(objA: T, objB: T): boolean {
-  try {
-    console.log('using orderedSameObject2');
-    
-    if (
-      typeof objA !== 'object' || 
-      typeof objB !== 'object' ||
-      Array.isArray(objA) ||
-      Array.isArray(objB) ||
-      objA === null ||
-      objB === null ||
-      objA === undefined ||
-      objB === undefined
-    ) {
-      return JSON.stringify(objA) === JSON.stringify(objB);
-    } 
-    
-    return JSON.stringify(
-      objA, 
-      Object.keys(objA).sort()
-    ) === JSON.stringify(
-      objB, 
-      Object.keys(objB).sort()
-    );
-  } catch (error) {
-    DyFM_Log.error(
-      'sameObjects()' + defaultErrorMsg,
-      error
-    );
-
-    throw error;
-  }
-}
-
-/**
- * compares the surface of two objects
- * @param objA 
- * @param objB 
- * @returns 
- */
-export function DyFM_sameObjectSurface<T>(objA: T, objB: T): boolean {
-  let result = true;
-
-  for (const key in objA) {
-    if (objA[key] !== objB[key]) {
-      result = false;
-      break;
-    }
-  }
-
-  return result;
-}
-
-/**
- * sets values if its existing on To, even if its null (but if undefined)
- * @param setOn
- * @param setTo 
- */
-export function DyFM_setExistingValuesOnly(setOn: any, setTo: any): void {
-  for (const key in setTo) {
-    if (setTo[key] != undefined) {
-      setOn[key] = setTo[key];
-    }
-  }
-}
-
-/**
- * delays the execution of a function
- * @param ms 
- * @returns 
- */
-export function DyFM_delay(ms: number): Promise<void> {
-  return new Promise((resolve): any => setTimeout(resolve, ms));
-}
-export const DyFM_sleep = DyFM_delay;
-export const DyFM_wait = DyFM_delay;
-
-/** 
- * WARNING: This function is recommended to use ONLY for limited instances,
- * because it can cause performance issues.
- */
-export function DyFM_waitUntil(
-  check: () => boolean, 
-  interval: number = 100,
-  timeout: number = 10000
-): Promise<void> {
-  return new Promise((resolve, reject): void => {
-    const startTime = Date.now();
-
-    const intervalId = setInterval((): void => {
-      if (check()) {
-        clearInterval(intervalId);
-        resolve();
-      } else if (Date.now() - startTime > timeout) {
-        clearInterval(intervalId);
-        reject('timeout');
-      }
-    }, interval);
-  });
-}
-
-/** 
- * WARNING: This function is recommended to use ONLY for limited instances,
- * because it can cause performance issues.
- * 
- * @example
- * const result = await DyFM_waitUntilAsync(
- *   () => check(),
- *   30 * second,
- *   5 * minute,
- * );
- */
-export function DyFM_waitUntilAsync(
-  check: () => Promise<boolean>, 
-  interval: number = 100,
-  timeout: number = 10000
-): Promise<void> {
-  return new Promise((resolve, reject): void => {
-    const startTime = Date.now();
-
-    const intervalId = setInterval(async (): Promise<void> => {
-      if (await check()) {
-        clearInterval(intervalId);
-        resolve();
-      } else if (Date.now() - startTime > timeout) {
-        clearInterval(intervalId);
-        reject('timeout');
-      }
-    }, interval);
-  });
-}
-
-/**
- * Creates a promise that resolves when the observable emits a value that passes the check function
- */
-export function DyFM_takeUntil<T>(
-  observable: Observable<T>, 
-  check: (value?: T) => boolean
-): Promise<T> {
-  return new Promise((resolve): void => {
-    const sub = observable.subscribe(
-      (value?: T): void => {
-        if (check(value)) {
-          sub.unsubscribe();
-          resolve(value as T);
-        }
-      }
-    );
-  });
-}
-
-/**
- * the return type of the sortForTrue function
- */
-export type DyFM_SortDirection = 0 | 1 | -1
-
-/**
- * You might be use getSortForTrueFn instead for a shorter expression
- * 
- * @param a 
- * @param b 
- * @param check 
- * @returns 
- * 
- * @example 
- * codes.sort((a,b) => sortForTrue(a,b,(c: Code) => c.haveImg));
- */
-export function DyFM_sortForTrue<T>(
-  a: T, 
-  b: T, 
-  check: (a: T) => boolean
-): DyFM_SortDirection {
-  const isA = check(a);
-
-  if (isA === check(b)) {
-    return 0;
-  } else if (isA) {
-    return -1;
-  } else {
-    return 1;
-  }
-}
-
-/**
- * returns a function that can be used to sort an array of objects
- * sorts so that the objects that have the value true for the checkFor function are at the beginning of the array
- * @param checkFor 
- * @returns 
- */
-export function DyFM_getSortForTrueFn<T>(
-  checkFor: (a: T) => boolean
-): (a: T, b: T) => DyFM_SortDirection {
-  return (a: T, b: T): DyFM_SortDirection => DyFM_sortForTrue<T>(a, b, checkFor);
-}
-
-/**
- * converts a JSONList to an array
- * @param JSONList 
- * @returns 
- */
-export function DyFM_JSONListify<T>(JSONList: any): T[] {
-  const result: T[] = [];
-
-  for (let i = 0; JSONList[i]; i++) {
-    result.push(JSONList[i]);
-  }
-
-  return result; 
-}
 
 /**
  * checks if the value is not null or undefined