@futdevpro/fsm-dynamo 1.15.17 → 1.15.20

package/src/_collections/utils/type-cloning-facility.util.spec.ts

@@ -1,51 +1,51 @@
-
-import { DyFM_TypeCloningFacility } from './type-cloning-facility.util';
-
-describe('| DyFM_TypeCloningFacility', () => {
-
-  it('| should clone a simple object', () => {
-    const original = { a: 1, b: 'test', c: true };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-  });
-
-  it('| should clone an object with nested objects', () => {
-    const original = { a: { b: { c: 2 } } };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-    expect(cloned.a).not.toBe(original.a);
-    expect(cloned.a.b).not.toBe(original.a.b);
-  });
-
-  xit('should handle circular references', () => {
-    const original: any = { a: 1 };
-    original.self = original;
-
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual({ a: 1, self: cloned });
-    expect(cloned).not.toBe(original);
-  });
-
-  it('| should clone arrays within objects', () => {
-    const original = { a: [1, 2, 3] };
-    const cloned = DyFM_TypeCloningFacility.clone(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned.a).not.toBe(original.a);
-  });
-
-  it('| should clone an array of objects', () => {
-    const original = [{ a: 1 }, { b: 2 }];
-    const cloned = DyFM_TypeCloningFacility.cloneArray(original);
-
-    expect(cloned).toEqual(original);
-    expect(cloned).not.toBe(original);
-    expect(cloned[0]).not.toBe(original[0]);
-    expect(cloned[1]).not.toBe(original[1]);
-  });
-});
+
+import { DyFM_TypeCloningFacility } from './type-cloning-facility.util';
+
+describe('| DyFM_TypeCloningFacility', () => {
+
+  it('| should clone a simple object', () => {
+    const original = { a: 1, b: 'test', c: true };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+  });
+
+  it('| should clone an object with nested objects', () => {
+    const original = { a: { b: { c: 2 } } };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(cloned.a).not.toBe(original.a);
+    expect(cloned.a.b).not.toBe(original.a.b);
+  });
+
+  xit('should handle circular references', () => {
+    const original: any = { a: 1 };
+    original.self = original;
+
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual({ a: 1, self: cloned });
+    expect(cloned).not.toBe(original);
+  });
+
+  it('| should clone arrays within objects', () => {
+    const original = { a: [1, 2, 3] };
+    const cloned = DyFM_TypeCloningFacility.clone(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned.a).not.toBe(original.a);
+  });
+
+  it('| should clone an array of objects', () => {
+    const original = [{ a: 1 }, { b: 2 }];
+    const cloned = DyFM_TypeCloningFacility.cloneArray(original);
+
+    expect(cloned).toEqual(original);
+    expect(cloned).not.toBe(original);
+    expect(cloned[0]).not.toBe(original[0]);
+    expect(cloned[1]).not.toBe(original[1]);
+  });
+});

package/src/_collections/utils/type-cloning-facility.util.ts

@@ -1,168 +1,168 @@
-export type DyFM_TCF = DyFM_TypeCloningFacility;
-
-/** 
- * 
- * 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 DyFM_TypeCloningFacility {
-
-  /**
-   * Clone an object
-   * @param object - The object to clone
-   * @param skip - An array of keys to skip
-   * @param affectedObjects - An array of objects that have already been cloned
-   * @param debug - Whether to log debug information
-   * @returns The cloned object
-   */
-  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 (object && typeof object === 'object'/* object.hasOwnProperty(key) */) {
-        const type: string = 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] as string
-            };
-
-            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;
-  }
-
-  /**
-   * Clone an array
-   * @param array - The array to clone
-   * @param skip - An array of keys to skip
-   * @param affectedObjects - An array of objects that have already been cloned
-   * @param debug - Whether to log debug information
-   * @returns The cloned array
-   */
-  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;
-  }
-
-  /**
-   * Store the circulation of an object
-   * @param object - The object to store the circulation of
-   * @returns The serialized object
-   */
-  static storeCirculation(object: any): string {
-    const cache = new Map();
-    const result = JSON.stringify(object, (key, value) => {
-      if (typeof value === 'object' && value !== null) {
-        if (cache.has(value)) {
-          return `__cycle__${cache.get(value)}`;
-        }
-        cache.set(value, cache.size);
-      }
-      return value;
-    });
-    return result;
-  }
-
-  /**
-   * Restore the circulation of an object
-   * @param serialized - The serialized object
-   * @returns The restored object
-   */
-  static restoreCirculation(serialized: string): any {
-    const cache = new Map();
-    const result = JSON.parse(serialized, (key, value) => {
-      if (typeof value === 'string' && value.startsWith('__cycle__')) {
-        return cache.get(parseInt(value.slice(9), 10));
-      }
-      if (typeof value === 'object' && value !== null) {
-        cache.set(cache.size, value);
-      }
-      return value;
-    });
-    return result;
-  }
-}
-
-interface ObjectCollector {
-  id: string;
-  clonedObject?: any;
-}
-
+export type DyFM_TCF = DyFM_TypeCloningFacility;
+
+/** 
+ * 
+ * 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 DyFM_TypeCloningFacility {
+
+  /**
+   * Clone an object
+   * @param object - The object to clone
+   * @param skip - An array of keys to skip
+   * @param affectedObjects - An array of objects that have already been cloned
+   * @param debug - Whether to log debug information
+   * @returns The cloned object
+   */
+  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 (object && typeof object === 'object'/* object.hasOwnProperty(key) */) {
+        const type: string = 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] as string
+            };
+
+            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;
+  }
+
+  /**
+   * Clone an array
+   * @param array - The array to clone
+   * @param skip - An array of keys to skip
+   * @param affectedObjects - An array of objects that have already been cloned
+   * @param debug - Whether to log debug information
+   * @returns The cloned array
+   */
+  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;
+  }
+
+  /**
+   * Store the circulation of an object
+   * @param object - The object to store the circulation of
+   * @returns The serialized object
+   */
+  static storeCirculation(object: any): string {
+    const cache = new Map();
+    const result = JSON.stringify(object, (key, value) => {
+      if (typeof value === 'object' && value !== null) {
+        if (cache.has(value)) {
+          return `__cycle__${cache.get(value)}`;
+        }
+        cache.set(value, cache.size);
+      }
+      return value;
+    });
+    return result;
+  }
+
+  /**
+   * Restore the circulation of an object
+   * @param serialized - The serialized object
+   * @returns The restored object
+   */
+  static restoreCirculation(serialized: string): any {
+    const cache = new Map();
+    const result = JSON.parse(serialized, (key, value) => {
+      if (typeof value === 'string' && value.startsWith('__cycle__')) {
+        return cache.get(parseInt(value.slice(9), 10));
+      }
+      if (typeof value === 'object' && value !== null) {
+        cache.set(cache.size, value);
+      }
+      return value;
+    });
+    return result;
+  }
+}
+
+interface ObjectCollector {
+  id: string;
+  clonedObject?: any;
+}
+