@futdevpro/fsm-dynamo 1.15.21 → 1.15.22

package/src/_collections/utils/object.util.spec.ts

@@ -1,646 +1,646 @@
-
-import { DyFM_Object } from './object.util';
-
-describe('| DyFM_Object', () => {
-
-  describe('| mapObjList', () => {
-    it('| should remap object list based on given paths', () => {
-      const objList = [
-        {
-          first: {
-            sub: { label: 'vlmi' },
-            dif: { name: 'asd' }
-          }
-        }
-      ];
-      const paths = [['first', 'sub', 'label'], ['first', 'dif', 'name']];
-      const expected = [{ label: 'vlmi', name: 'asd' }];
-
-      const result = DyFM_Object.mapObjList(objList, paths);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| getNestedData', () => {
-    it('| should return nested value from object', () => {
-      const obj = {
-        nestLvl1: {
-          nestLvl2: {
-            nestLvl3: 'value'
-          }
-        }
-      };
-      const path = ['nestLvl1', 'nestLvl2', 'nestLvl3'];
-
-      const result = DyFM_Object.getNestedData(obj, path);
-
-      expect(result).toBe('value');
-    });
-  });
-
-  describe('| nestData', () => {
-    xit('should nest data at specified path', () => {
-      const obj = {};
-      const path = ['level1', 'level2'];
-      const value = 'nestedValue';
-      const expected = { level1: { level2: 'nestedValue' } };
-
-      const result = DyFM_Object.nestData(obj, path, value);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| addToNestedData', () => {
-    it('| should add to nested data at specified path', () => {
-      const obj = { level1: { level2: 5 } };
-      const path = ['level1', 'level2'];
-      const valueToAdd = 3;
-      const expected = { level1: { level2: 8 } };
-
-      const result = DyFM_Object.addToNestedData(obj, path, valueToAdd);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| pushToNestedData', () => {
-    it('| should push to nested array at specified path', () => {
-      const obj = { level1: { level2: [1, 2] } };
-      const path = ['level1', 'level2'];
-      const valueToPush = 3;
-      const expected = { level1: { level2: [1, 2, 3] } };
-
-      const result = DyFM_Object.pushToNestedData(obj, path, valueToPush);
-
-      expect(result).toEqual(expected);
-    });
-
-    it('| should create an array and push if none exists', () => {
-      const obj = { level1: {} };
-      const path = ['level1', 'level2'];
-      const valueToPush = 3;
-      const expected = { level1: { level2: [3] } };
-
-      const result = DyFM_Object.pushToNestedData(obj, path, valueToPush);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| nestRecursiveListedData', () => {
-    it('| should nest data in recursive list structure', () => {
-      const obj = { listKey: [{ listKey: [{ listKey: [{}] }] }] };
-      const nestedListKey = 'listKey';
-      const nestIndexes = [0, 0, 0];
-      const value = 'nestedValue';
-      const expected = { listKey: [{ listKey: [{ listKey: ['nestedValue'] }] }] };
-
-      const result = DyFM_Object.nestRecursiveListedData(obj, nestedListKey, nestIndexes, value);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  xdescribe('| resolveCirculation', () => {
-    xit('should resolve circular references in data', () => {
-      const obj: any = { inner: {} };
-      obj.inner.self = obj;
-      const expected = { inner: { self: 'CIRCULATION:Object.inner' } };
-
-      const result = DyFM_Object.resolveCirculation(obj);
-
-      expect(result).toEqual(expected);
-    });
-
-    xit('should resolve self-circular root reference', () => {
-      const obj: any = {};
-      obj.self = obj;
-      const expected = { self: 'CIRCULATION:ROOT;Object.self' };
-
-      const result = DyFM_Object.resolveCirculation(obj);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| findCirculations', () => {
-    xit('should find circular references in data', () => {
-      const obj: any = {};
-      obj.self = obj;
-      const expected = [{
-        object: obj,
-        pathsOfAllDuplications: ['ROOT;Object', 'self']
-      }];
-
-      const result = DyFM_Object.findCirculations(obj);
-
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('| failableSafeParseJSON', () => {
-    
-    describe('| Basic JSON parsing', () => {
-      it('| should parse valid JSON object', () => {
-        const input = '{"name": "test", "value": 123}';
-        const expected = { name: 'test', value: 123 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse valid JSON array', () => {
-        const input = '[1, 2, 3, "test"]';
-        const expected = [1, 2, 3, 'test'];
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse valid JSON string', () => {
-        const input = '"simple string"';
-        const expected = 'simple string';
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toBe(expected);
-      });
-
-      it('| should parse valid JSON number', () => {
-        const input = '42.5';
-        const expected = 42.5;
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toBe(expected);
-      });
-
-      it('| should parse valid JSON boolean', () => {
-        const input = 'true';
-        const expected = true;
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toBe(expected);
-      });
-
-      it('| should parse valid JSON null', () => {
-        const input = 'null';
-        const expected = null;
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toBe(expected);
-      });
-    });
-
-    describe('| JSON extraction from code blocks', () => {
-      it('| should extract JSON from ```json code block', () => {
-        const input = '```json\n{"name": "test", "value": 123}\n```';
-        const expected = { name: 'test', value: 123 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should extract JSON from ```json code block with extra text', () => {
-        const input = 'Here is the JSON:\n```json\n{"name": "test", "value": 123}\n```\nEnd of JSON';
-        const expected = { name: 'test', value: 123 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should extract complex JSON from ```json code block', () => {
-        const input = '```json\n{\n  "users": [\n    {"id": 1, "name": "John"},\n    {"id": 2, "name": "Jane"}\n  ],\n  "total": 2\n}\n```';
-        const expected = {
-          users: [
-            { id: 1, name: 'John' },
-            { id: 2, name: 'Jane' }
-          ],
-          total: 2
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should handle JSON with newlines in ```json code block', () => {
-        const input = '```json\n{\n  "message": "Line 1\\nLine 2\\nLine 3",\n  "type": "multiline"\n}\n```';
-        const expected = {
-          message: 'Line 1\nLine 2\nLine 3',
-          type: 'multiline'
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('| JSON extraction without code blocks', () => {
-      it('| should parse JSON when no code block markers present', () => {
-        const input = '{"name": "test", "value": 123}';
-        const expected = { name: 'test', value: 123 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('| Complex and stringified content', () => {
-      it('| should parse JSON containing escaped quotes', () => {
-        const input = '{"message": "He said \\"Hello\\" to her"}';
-        const expected = { message: 'He said "Hello" to her' };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON containing stringified JSON', () => {
-        const input = '{"data": "{\\"nested\\": \\"value\\", \\"number\\": 42}"}';
-        const expected = { data: '{"nested": "value", "number": 42}' };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with complex nested structures', () => {
-        const input = '{"config": {"database": {"host": "localhost", "port": 5432}, "cache": {"ttl": 3600}}, "features": ["auth", "cache"]}';
-        const expected = {
-          config: {
-            database: { host: 'localhost', port: 5432 },
-            cache: { ttl: 3600 }
-          },
-          features: ['auth', 'cache']
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with special characters and unicode', () => {
-        const input = '{"unicode": "🚀 Test ñáéíóú", "special": "Line1\\nLine2\\tTabbed"}';
-        const expected = {
-          unicode: '🚀 Test ñáéíóú',
-          special: 'Line1\nLine2\tTabbed'
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with very long strings', () => {
-        const longString = 'a'.repeat(1000);
-        const input = `{"longString": "${longString}", "length": ${longString.length}}`;
-        const expected = { longString: longString, length: 1000 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with deep nesting', () => {
-        const input = '{"level1": {"level2": {"level3": {"level4": {"level5": "deep value"}}}}}';
-        const expected = {
-          level1: {
-            level2: {
-              level3: {
-                level4: {
-                  level5: 'deep value'
-                }
-              }
-            }
-          }
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('| Error handling and validation', () => {
-      it('| should throw error for null input', () => {
-        expect(() => {
-          DyFM_Object.failableSafeParseJSON(null as any);
-        }).toThrow();
-      });
-
-      it('| should throw error for undefined input', () => {
-        expect(() => {
-          DyFM_Object.failableSafeParseJSON(undefined as any);
-        }).toThrow();
-      });
-
-      it('| should throw error for empty string', () => {
-        expect(() => {
-          DyFM_Object.failableSafeParseJSON('');
-        }).toThrow();
-      });
-
-      it('| should throw enhanced error for malformed JSON with line context', () => {
-        const input = '{\n  "name": "test",\n  "value": 123,\n  "invalid": \n}';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          const errorMessage = (error as Error).message;
-          expect(errorMessage).toContain('JSON parsing failed');
-          // The error should mention the parsing issue
-          expect(errorMessage.length).toBeGreaterThan(10);
-        }
-      });
-
-      it('| should throw enhanced error for missing comma with detailed context', () => {
-        const input = '{\n  "name": "test",\n  "value": 123\n  "missing_comma": true\n}';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          const errorMessage = (error as Error).message;
-          expect(errorMessage).toContain('JSON parsing failed');
-          
-          // Should show enhanced error format with line info when position is available
-          if (errorMessage.includes('at position')) {
-            expect(errorMessage).toContain('line');
-            expect(errorMessage).toContain('Error at line');
-          }
-        }
-      });
-
-      it('| should throw enhanced error for unterminated string with context', () => {
-        const input = '{\n  "name": "unterminated string\n  "value": 123\n}';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          const errorMessage = (error as Error).message;
-          expect(errorMessage).toContain('JSON parsing failed');
-          expect(errorMessage.length).toBeGreaterThan(10);
-        }
-      });
-
-      it('| should throw enhanced error for unexpected end of input', () => {
-        const input = '{\n  "name": "test",\n  "value": 123';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          const errorMessage = (error as Error).message;
-          expect(errorMessage).toContain('JSON parsing failed');
-          expect(errorMessage.length).toBeGreaterThan(10);
-        }
-      });
-
-      it('| should provide enhanced error context for code block JSON', () => {
-        const input = '```json\n{\n  "valid": true,\n  "invalid": [\n    1,\n    2,\n    3\n    4\n  ]\n}\n```';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          const errorMessage = (error as Error).message;
-          
-          // Should contain JSON parsing error info
-          expect(errorMessage).toContain('JSON parsing failed');
-          
-          // If enhanced error reporting works, should show context
-          if (errorMessage.includes('Error at line')) {
-            expect(errorMessage).toContain('>>>'); // Error line marker
-            expect(errorMessage).toMatch(/\d+:/); // Line numbers
-          }
-        }
-      });
-
-      it('| should show context lines when error position is available', () => {
-        // This JSON has a clear syntax error that should trigger enhanced reporting
-        const input = '```json\n{\n  "name": "test",\n  "value": 123,\n  "missing_comma": true\n  "error": "here"\n}\n```';
-        
-        try {
-          DyFM_Object.failableSafeParseJSON(input);
-          fail('Expected error to be thrown');
-        } catch (error) {
-          const errorMessage = (error as Error).message;
-          
-          expect(errorMessage).toContain('JSON parsing failed');
-          
-          // Should show enhanced error format when position info is available
-          if (errorMessage.includes('at position')) {
-            // Should show line context
-            expect(errorMessage).toContain('Error at line');
-            expect(errorMessage).toContain('>>>'); // Error line marker
-            
-            // Should show multiple context lines
-            const contextLines = errorMessage.split('\n').filter(line => 
-              line.match(/^\s*(\d+|>>>)/)
-            );
-            expect(contextLines.length).toBeGreaterThan(0);
-          }
-        }
-      });
-    });
-
-    describe('| Edge cases and robustness', () => {
-      it('| should handle JSON with only whitespace', () => {
-        expect(() => {
-          DyFM_Object.failableSafeParseJSON('   \n\t   ');
-        }).toThrow();
-      });
-
-      it('| should handle very large JSON objects', () => {
-        const largeObj: any = {};
-        for (let i = 0; i < 100; i++) {
-          largeObj[`key${i}`] = `value${i}`;
-        }
-        const input = JSON.stringify(largeObj);
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(largeObj);
-        expect(Object.keys(result)).toHaveSize(100);
-      });
-
-      it('| should handle JSON with mixed types in arrays', () => {
-        const input = '[1, "string", true, null, {"nested": "object"}, [1, 2, 3]]';
-        const expected = [1, 'string', true, null, { nested: 'object' }, [1, 2, 3]];
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should handle JSON with scientific notation', () => {
-        const input = '{"small": 1e-10, "large": 1e10, "normal": 123.45}';
-        const expected = { small: 1e-10, large: 1e10, normal: 123.45 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should handle JSON with negative numbers', () => {
-        const input = '{"negative": -42, "positiveZero": 0, "negativeZero": -0}';
-        const expected = { negative: -42, positiveZero: 0, negativeZero: -0 };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should preserve object key order', () => {
-        const input = '{"z": 1, "a": 2, "m": 3}';
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        const keys = Object.keys(result);
-        expect(keys).toEqual(['z', 'a', 'm']);
-      });
-
-      it('| should handle empty objects and arrays', () => {
-        const input = '{"empty_obj": {}, "empty_arr": [], "null_val": null}';
-        const expected = { empty_obj: {}, empty_arr: [], null_val: null };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('| Real-world scenarios', () => {
-      it('| should parse API response format', () => {
-        const input = '{"status": "success", "data": {"users": [{"id": 1, "name": "John"}]}, "pagination": {"page": 1, "total": 100}}';
-        const expected = {
-          status: 'success',
-          data: { users: [{ id: 1, name: 'John' }] },
-          pagination: { page: 1, total: 100 }
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse configuration format', () => {
-        const input = '{"database": {"host": "localhost", "port": 5432, "ssl": true}, "logging": {"level": "info", "file": "/var/log/app.log"}}';
-        const expected = {
-          database: { host: 'localhost', port: 5432, ssl: true },
-          logging: { level: 'info', file: '/var/log/app.log' }
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON from AI model response with markdown', () => {
-        const input = 'Here is the requested JSON:\n\n```json\n{\n  "response": "success",\n  "data": {\n    "generated": true,\n    "model": "gpt-4"\n  }\n}\n```\n\nThis should work correctly.';
-        const expected = {
-          response: 'success',
-          data: {
-            generated: true,
-            model: 'gpt-4'
-          }
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with sub-inserted JSON', () => {
-        const sub = JSON.stringify({
-          name: "sub", 
-          value: 456
-        });
-        const input = JSON.stringify({
-          name: "test", 
-          value: 123, 
-          sub: sub
-        });
-        const expected = {
-          name: 'test',
-          value: 123,
-          sub: sub
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with sub-inserted JSON in a code block', () => {
-        const input = 'things around ```json\n' + JSON.stringify({
-          name: "test", 
-          value: 123, 
-          sub: '```json\n{"name": "sub", "value": 456}\n```'
-        }) + '\n``` things around';
-        const expected = {
-          name: 'test',
-          value: 123,
-          sub: '```json\n{"name": "sub", "value": 456}\n```'
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with sub-inserted JSON in a code block with only ```json within', () => {
-        const input = JSON.stringify({
-          name: "test", 
-          value: 123, 
-          sub: "```json\n{\"name\": \"sub\", \"value\": 456}\n```"
-        });
-        const expected = {
-          name: 'test',
-          value: 123,
-          sub: "```json\n{\"name\": \"sub\", \"value\": 456}\n```"
-        };
-
-        const result = DyFM_Object.failableSafeParseJSON(input);
-
-        expect(result).toEqual(expected);
-      });
-
-      it('| should parse JSON with sub-inserted commas', () => {
-        const input = JSON.stringify({
-          name: "test", 
-          value: 123, 
-          sub: 'content wit \"commas\" and "commas"'
-        });
-        const expected = {
-          name: 'test',
-          value: 123,
-          sub: 'content wit \"commas\" and "commas"'
-        };
-        const result = DyFM_Object.failableSafeParseJSON(input);
-        expect(result).toEqual(expected);
-      });
-
-
-
-
-    });
-  });
-
-});
+
+import { DyFM_Object } from './object.util';
+
+describe('| DyFM_Object', () => {
+
+  describe('| mapObjList', () => {
+    it('| should remap object list based on given paths', () => {
+      const objList = [
+        {
+          first: {
+            sub: { label: 'vlmi' },
+            dif: { name: 'asd' }
+          }
+        }
+      ];
+      const paths = [['first', 'sub', 'label'], ['first', 'dif', 'name']];
+      const expected = [{ label: 'vlmi', name: 'asd' }];
+
+      const result = DyFM_Object.mapObjList(objList, paths);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| getNestedData', () => {
+    it('| should return nested value from object', () => {
+      const obj = {
+        nestLvl1: {
+          nestLvl2: {
+            nestLvl3: 'value'
+          }
+        }
+      };
+      const path = ['nestLvl1', 'nestLvl2', 'nestLvl3'];
+
+      const result = DyFM_Object.getNestedData(obj, path);
+
+      expect(result).toBe('value');
+    });
+  });
+
+  describe('| nestData', () => {
+    xit('should nest data at specified path', () => {
+      const obj = {};
+      const path = ['level1', 'level2'];
+      const value = 'nestedValue';
+      const expected = { level1: { level2: 'nestedValue' } };
+
+      const result = DyFM_Object.nestData(obj, path, value);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| addToNestedData', () => {
+    it('| should add to nested data at specified path', () => {
+      const obj = { level1: { level2: 5 } };
+      const path = ['level1', 'level2'];
+      const valueToAdd = 3;
+      const expected = { level1: { level2: 8 } };
+
+      const result = DyFM_Object.addToNestedData(obj, path, valueToAdd);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| pushToNestedData', () => {
+    it('| should push to nested array at specified path', () => {
+      const obj = { level1: { level2: [1, 2] } };
+      const path = ['level1', 'level2'];
+      const valueToPush = 3;
+      const expected = { level1: { level2: [1, 2, 3] } };
+
+      const result = DyFM_Object.pushToNestedData(obj, path, valueToPush);
+
+      expect(result).toEqual(expected);
+    });
+
+    it('| should create an array and push if none exists', () => {
+      const obj = { level1: {} };
+      const path = ['level1', 'level2'];
+      const valueToPush = 3;
+      const expected = { level1: { level2: [3] } };
+
+      const result = DyFM_Object.pushToNestedData(obj, path, valueToPush);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| nestRecursiveListedData', () => {
+    it('| should nest data in recursive list structure', () => {
+      const obj = { listKey: [{ listKey: [{ listKey: [{}] }] }] };
+      const nestedListKey = 'listKey';
+      const nestIndexes = [0, 0, 0];
+      const value = 'nestedValue';
+      const expected = { listKey: [{ listKey: [{ listKey: ['nestedValue'] }] }] };
+
+      const result = DyFM_Object.nestRecursiveListedData(obj, nestedListKey, nestIndexes, value);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  xdescribe('| resolveCirculation', () => {
+    xit('should resolve circular references in data', () => {
+      const obj: any = { inner: {} };
+      obj.inner.self = obj;
+      const expected = { inner: { self: 'CIRCULATION:Object.inner' } };
+
+      const result = DyFM_Object.resolveCirculation(obj);
+
+      expect(result).toEqual(expected);
+    });
+
+    xit('should resolve self-circular root reference', () => {
+      const obj: any = {};
+      obj.self = obj;
+      const expected = { self: 'CIRCULATION:ROOT;Object.self' };
+
+      const result = DyFM_Object.resolveCirculation(obj);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| findCirculations', () => {
+    xit('should find circular references in data', () => {
+      const obj: any = {};
+      obj.self = obj;
+      const expected = [{
+        object: obj,
+        pathsOfAllDuplications: ['ROOT;Object', 'self']
+      }];
+
+      const result = DyFM_Object.findCirculations(obj);
+
+      expect(result).toEqual(expected);
+    });
+  });
+
+  describe('| failableSafeParseJSON', () => {
+    
+    describe('| Basic JSON parsing', () => {
+      it('| should parse valid JSON object', () => {
+        const input = '{"name": "test", "value": 123}';
+        const expected = { name: 'test', value: 123 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse valid JSON array', () => {
+        const input = '[1, 2, 3, "test"]';
+        const expected = [1, 2, 3, 'test'];
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse valid JSON string', () => {
+        const input = '"simple string"';
+        const expected = 'simple string';
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toBe(expected);
+      });
+
+      it('| should parse valid JSON number', () => {
+        const input = '42.5';
+        const expected = 42.5;
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toBe(expected);
+      });
+
+      it('| should parse valid JSON boolean', () => {
+        const input = 'true';
+        const expected = true;
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toBe(expected);
+      });
+
+      it('| should parse valid JSON null', () => {
+        const input = 'null';
+        const expected = null;
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toBe(expected);
+      });
+    });
+
+    describe('| JSON extraction from code blocks', () => {
+      it('| should extract JSON from ```json code block', () => {
+        const input = '```json\n{"name": "test", "value": 123}\n```';
+        const expected = { name: 'test', value: 123 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should extract JSON from ```json code block with extra text', () => {
+        const input = 'Here is the JSON:\n```json\n{"name": "test", "value": 123}\n```\nEnd of JSON';
+        const expected = { name: 'test', value: 123 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should extract complex JSON from ```json code block', () => {
+        const input = '```json\n{\n  "users": [\n    {"id": 1, "name": "John"},\n    {"id": 2, "name": "Jane"}\n  ],\n  "total": 2\n}\n```';
+        const expected = {
+          users: [
+            { id: 1, name: 'John' },
+            { id: 2, name: 'Jane' }
+          ],
+          total: 2
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should handle JSON with newlines in ```json code block', () => {
+        const input = '```json\n{\n  "message": "Line 1\\nLine 2\\nLine 3",\n  "type": "multiline"\n}\n```';
+        const expected = {
+          message: 'Line 1\nLine 2\nLine 3',
+          type: 'multiline'
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe('| JSON extraction without code blocks', () => {
+      it('| should parse JSON when no code block markers present', () => {
+        const input = '{"name": "test", "value": 123}';
+        const expected = { name: 'test', value: 123 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe('| Complex and stringified content', () => {
+      it('| should parse JSON containing escaped quotes', () => {
+        const input = '{"message": "He said \\"Hello\\" to her"}';
+        const expected = { message: 'He said "Hello" to her' };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON containing stringified JSON', () => {
+        const input = '{"data": "{\\"nested\\": \\"value\\", \\"number\\": 42}"}';
+        const expected = { data: '{"nested": "value", "number": 42}' };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with complex nested structures', () => {
+        const input = '{"config": {"database": {"host": "localhost", "port": 5432}, "cache": {"ttl": 3600}}, "features": ["auth", "cache"]}';
+        const expected = {
+          config: {
+            database: { host: 'localhost', port: 5432 },
+            cache: { ttl: 3600 }
+          },
+          features: ['auth', 'cache']
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with special characters and unicode', () => {
+        const input = '{"unicode": "🚀 Test ñáéíóú", "special": "Line1\\nLine2\\tTabbed"}';
+        const expected = {
+          unicode: '🚀 Test ñáéíóú',
+          special: 'Line1\nLine2\tTabbed'
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with very long strings', () => {
+        const longString = 'a'.repeat(1000);
+        const input = `{"longString": "${longString}", "length": ${longString.length}}`;
+        const expected = { longString: longString, length: 1000 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with deep nesting', () => {
+        const input = '{"level1": {"level2": {"level3": {"level4": {"level5": "deep value"}}}}}';
+        const expected = {
+          level1: {
+            level2: {
+              level3: {
+                level4: {
+                  level5: 'deep value'
+                }
+              }
+            }
+          }
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe('| Error handling and validation', () => {
+      it('| should throw error for null input', () => {
+        expect(() => {
+          DyFM_Object.failableSafeParseJSON(null as any);
+        }).toThrow();
+      });
+
+      it('| should throw error for undefined input', () => {
+        expect(() => {
+          DyFM_Object.failableSafeParseJSON(undefined as any);
+        }).toThrow();
+      });
+
+      it('| should throw error for empty string', () => {
+        expect(() => {
+          DyFM_Object.failableSafeParseJSON('');
+        }).toThrow();
+      });
+
+      it('| should throw enhanced error for malformed JSON with line context', () => {
+        const input = '{\n  "name": "test",\n  "value": 123,\n  "invalid": \n}';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          const errorMessage = (error as Error).message;
+          expect(errorMessage).toContain('JSON parsing failed');
+          // The error should mention the parsing issue
+          expect(errorMessage.length).toBeGreaterThan(10);
+        }
+      });
+
+      it('| should throw enhanced error for missing comma with detailed context', () => {
+        const input = '{\n  "name": "test",\n  "value": 123\n  "missing_comma": true\n}';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          const errorMessage = (error as Error).message;
+          expect(errorMessage).toContain('JSON parsing failed');
+          
+          // Should show enhanced error format with line info when position is available
+          if (errorMessage.includes('at position')) {
+            expect(errorMessage).toContain('line');
+            expect(errorMessage).toContain('Error at line');
+          }
+        }
+      });
+
+      it('| should throw enhanced error for unterminated string with context', () => {
+        const input = '{\n  "name": "unterminated string\n  "value": 123\n}';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          const errorMessage = (error as Error).message;
+          expect(errorMessage).toContain('JSON parsing failed');
+          expect(errorMessage.length).toBeGreaterThan(10);
+        }
+      });
+
+      it('| should throw enhanced error for unexpected end of input', () => {
+        const input = '{\n  "name": "test",\n  "value": 123';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          expect(error).toBeInstanceOf(Error);
+          const errorMessage = (error as Error).message;
+          expect(errorMessage).toContain('JSON parsing failed');
+          expect(errorMessage.length).toBeGreaterThan(10);
+        }
+      });
+
+      it('| should provide enhanced error context for code block JSON', () => {
+        const input = '```json\n{\n  "valid": true,\n  "invalid": [\n    1,\n    2,\n    3\n    4\n  ]\n}\n```';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          const errorMessage = (error as Error).message;
+          
+          // Should contain JSON parsing error info
+          expect(errorMessage).toContain('JSON parsing failed');
+          
+          // If enhanced error reporting works, should show context
+          if (errorMessage.includes('Error at line')) {
+            expect(errorMessage).toContain('>>>'); // Error line marker
+            expect(errorMessage).toMatch(/\d+:/); // Line numbers
+          }
+        }
+      });
+
+      it('| should show context lines when error position is available', () => {
+        // This JSON has a clear syntax error that should trigger enhanced reporting
+        const input = '```json\n{\n  "name": "test",\n  "value": 123,\n  "missing_comma": true\n  "error": "here"\n}\n```';
+        
+        try {
+          DyFM_Object.failableSafeParseJSON(input);
+          fail('Expected error to be thrown');
+        } catch (error) {
+          const errorMessage = (error as Error).message;
+          
+          expect(errorMessage).toContain('JSON parsing failed');
+          
+          // Should show enhanced error format when position info is available
+          if (errorMessage.includes('at position')) {
+            // Should show line context
+            expect(errorMessage).toContain('Error at line');
+            expect(errorMessage).toContain('>>>'); // Error line marker
+            
+            // Should show multiple context lines
+            const contextLines = errorMessage.split('\n').filter(line => 
+              line.match(/^\s*(\d+|>>>)/)
+            );
+            expect(contextLines.length).toBeGreaterThan(0);
+          }
+        }
+      });
+    });
+
+    describe('| Edge cases and robustness', () => {
+      it('| should handle JSON with only whitespace', () => {
+        expect(() => {
+          DyFM_Object.failableSafeParseJSON('   \n\t   ');
+        }).toThrow();
+      });
+
+      it('| should handle very large JSON objects', () => {
+        const largeObj: any = {};
+        for (let i = 0; i < 100; i++) {
+          largeObj[`key${i}`] = `value${i}`;
+        }
+        const input = JSON.stringify(largeObj);
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(largeObj);
+        expect(Object.keys(result)).toHaveSize(100);
+      });
+
+      it('| should handle JSON with mixed types in arrays', () => {
+        const input = '[1, "string", true, null, {"nested": "object"}, [1, 2, 3]]';
+        const expected = [1, 'string', true, null, { nested: 'object' }, [1, 2, 3]];
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should handle JSON with scientific notation', () => {
+        const input = '{"small": 1e-10, "large": 1e10, "normal": 123.45}';
+        const expected = { small: 1e-10, large: 1e10, normal: 123.45 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should handle JSON with negative numbers', () => {
+        const input = '{"negative": -42, "positiveZero": 0, "negativeZero": -0}';
+        const expected = { negative: -42, positiveZero: 0, negativeZero: -0 };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should preserve object key order', () => {
+        const input = '{"z": 1, "a": 2, "m": 3}';
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        const keys = Object.keys(result);
+        expect(keys).toEqual(['z', 'a', 'm']);
+      });
+
+      it('| should handle empty objects and arrays', () => {
+        const input = '{"empty_obj": {}, "empty_arr": [], "null_val": null}';
+        const expected = { empty_obj: {}, empty_arr: [], null_val: null };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+    });
+
+    describe('| Real-world scenarios', () => {
+      it('| should parse API response format', () => {
+        const input = '{"status": "success", "data": {"users": [{"id": 1, "name": "John"}]}, "pagination": {"page": 1, "total": 100}}';
+        const expected = {
+          status: 'success',
+          data: { users: [{ id: 1, name: 'John' }] },
+          pagination: { page: 1, total: 100 }
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse configuration format', () => {
+        const input = '{"database": {"host": "localhost", "port": 5432, "ssl": true}, "logging": {"level": "info", "file": "/var/log/app.log"}}';
+        const expected = {
+          database: { host: 'localhost', port: 5432, ssl: true },
+          logging: { level: 'info', file: '/var/log/app.log' }
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON from AI model response with markdown', () => {
+        const input = 'Here is the requested JSON:\n\n```json\n{\n  "response": "success",\n  "data": {\n    "generated": true,\n    "model": "gpt-4"\n  }\n}\n```\n\nThis should work correctly.';
+        const expected = {
+          response: 'success',
+          data: {
+            generated: true,
+            model: 'gpt-4'
+          }
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with sub-inserted JSON', () => {
+        const sub = JSON.stringify({
+          name: "sub", 
+          value: 456
+        });
+        const input = JSON.stringify({
+          name: "test", 
+          value: 123, 
+          sub: sub
+        });
+        const expected = {
+          name: 'test',
+          value: 123,
+          sub: sub
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with sub-inserted JSON in a code block', () => {
+        const input = 'things around ```json\n' + JSON.stringify({
+          name: "test", 
+          value: 123, 
+          sub: '```json\n{"name": "sub", "value": 456}\n```'
+        }) + '\n``` things around';
+        const expected = {
+          name: 'test',
+          value: 123,
+          sub: '```json\n{"name": "sub", "value": 456}\n```'
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with sub-inserted JSON in a code block with only ```json within', () => {
+        const input = JSON.stringify({
+          name: "test", 
+          value: 123, 
+          sub: "```json\n{\"name\": \"sub\", \"value\": 456}\n```"
+        });
+        const expected = {
+          name: 'test',
+          value: 123,
+          sub: "```json\n{\"name\": \"sub\", \"value\": 456}\n```"
+        };
+
+        const result = DyFM_Object.failableSafeParseJSON(input);
+
+        expect(result).toEqual(expected);
+      });
+
+      it('| should parse JSON with sub-inserted commas', () => {
+        const input = JSON.stringify({
+          name: "test", 
+          value: 123, 
+          sub: 'content wit \"commas\" and "commas"'
+        });
+        const expected = {
+          name: 'test',
+          value: 123,
+          sub: 'content wit \"commas\" and "commas"'
+        };
+        const result = DyFM_Object.failableSafeParseJSON(input);
+        expect(result).toEqual(expected);
+      });
+
+
+
+
+    });
+  });
+
+});