@futdevpro/fsm-dynamo 1.16.39 → 1.16.40

package/build/_collections/utils/object.util.js

@@ -1,596 +1,596 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_Object = void 0;
-const log_util_1 = require("./log.util");
-const json_error_helper_util_1 = require("./json-error-helper.util");
-const string_util_1 = require("./string.util");
-class DyFM_Object {
-    static 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
-     * @param objList object list to map
-     * @param paths string list of path etc.:
-     * ```ts
-     * [ [ 'first', 'sub', 'label' ], [ 'first', 'dif', 'name' ] ]
-     * ```
-     * will be...
-     * from
-     * ```ts
-     * {
-     *   first: {
-     *     sub: {
-     *       label: 'vlmi'
-     *     },
-     *     dif: {
-     *       name: 'asd'
-     *     }
-     *   }
-     * }[]
-     * ```
-     * to
-     * ```
-     * { label: 'vlmi', name: 'asd' }[]
-     * ```
-     * @returns remapped object list (the final obj will use the deepest keys)
-     */
-    static mapObjList(objList, paths) {
-        let newObjList = [...objList];
-        newObjList = newObjList.map((obj) => {
-            const newObj = {};
-            paths.forEach((path) => {
-                newObj[path[path.length - 1]] = this.getNestedData(obj, path);
-            });
-            return newObj;
-        });
-        return newObjList;
-    }
-    /**
-     * returns nested value from object
-     * @param parentObj data source object
-     * @param nestedDataKeys path of value as string list
-     * etc.: ['nestLvl1', 'nestLvl2', 'nestLvl3'] as parentObj.nestLvl1.nestLvl2.nestLvl3
-     * @returns data from object by path
-     */
-    static getNestedData(parentObj, nestedDataKeys) {
-        let newData = this.clone(parentObj); // {...parentObj};
-        nestedDataKeys.forEach((dk) => {
-            if (newData) {
-                newData = newData[dk];
-            }
-        });
-        return newData;
-    }
-    /**
-     * recursive function that nests data
-     * @param newData the object that that is needed to be updated
-     * @param nestKeys the path where the data should be updated
-     * @param dataToSet the actual value that will be setted
-     * @returns modified data
-     */
-    static nestData(parentObj, nestKeys, dataToSet) {
-        const newData = this.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;
-    }
-    /**
-     * recursive function that adds to nested data
-     * @param newData the object that that is needed to be updated
-     * @param nestKeys the path where the data should be updated
-     * @param dataToAdd the actual value that will be setted
-     * @returns modified data
-     */
-    static addToNestedData(parentObj, nestKeys, dataToAdd) {
-        const newData = this.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;
-    }
-    /**
-     * recursive function that pushes to nested data
-     * @param newData the object that that is needed to be updated
-     * @param nestKeys the path where the data should be updated
-     * @param dataToPush the actual value that will be setted
-     * @returns modified data
-     */
-    static pushToNestedData(parentObj, nestKeys, dataToPush) {
-        const newData = this.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]])) {
-                newData[nestKeys[0]].push(dataToPush);
-            }
-            else {
-                newData[nestKeys[0]] = [dataToPush];
-            }
-        }
-        return newData;
-    }
-    /**
-     * recursive function that nests data on recursive data structure etc.: xData: { ..., 'nestedListKey': xData[] }
-     * @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 seted on location
-     * @returns modified data
-     */
-    static nestRecursiveListedData(parentObj, nestedListKey, nestIndexes, dataToSet) {
-        const newData = this.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);
-        }
-        else {
-            newData[nestedListKey][nestIndexes[0]] = dataToSet;
-        }
-        return newData;
-    }
-    static 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(data, location = [('ROOT;' + data?.constructor?.name)], objs = []) {
-        if (!data || typeof data !== 'object') {
-            return data;
-        }
-        else if (objs.includes(data)) {
-            return 'CIRCULATION:' + location.join('.');
-        }
-        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) => {
-            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, location = [('ROOT;' + data?.constructor?.name)], objs = [], duplications = []) {
-        if (!data || typeof data !== 'object') {
-            return duplications;
-        }
-        else if (objs.includes(data)) {
-            duplications.push({
-                object: data,
-                pathsOfAllDuplications: location,
-            });
-        }
-        Object.keys(data).forEach((key) => {
-            this.findCirculations(data[key], [...location, key], [...objs, data], duplications);
-        });
-        return duplications;
-    }
-    /**
-     * removes all undefined (will keep all null, false, 0, '', NaN etc.)
-     *
-     * (not supports lists in lists!)
-     *
-     * (this also modifies the original object in place)
-     */
-    static safeCleanObject(obj) {
-        try {
-            return this.cleanObject(obj);
-        }
-        catch (error) {
-            log_util_1.DyFM_Log.error('Error cleaning object:', error);
-            return obj;
-        }
-    }
-    /**
-     * cleans the object, by removing all undefined values (but keeps all null, false, 0, '', NaN etc.)
-     * (this is a deep clean)
-     *
-     * (this also modifies the original object in place)
-     */
-    static cleanObject(obj, cleanings = []) {
-        if (!obj || typeof obj !== 'object' || cleanings.includes(obj)) {
-            return obj;
-        }
-        cleanings.push(obj);
-        Object.keys(obj).forEach((key) => {
-            if (obj[key] === undefined) {
-                delete obj[key];
-            }
-            else if (Array.isArray(obj[key])) {
-                obj[key].forEach((item) => {
-                    if (typeof item === 'object') {
-                        this.cleanObject(item, cleanings);
-                    }
-                });
-            }
-            else if (typeof obj[key] === 'object') {
-                this.cleanObject(obj[key], cleanings);
-            }
-        });
-        return obj;
-    }
-    /**
-     * merges two objects, if the target object is not an object, it will be replaced by the source object
-     * it will iterate through the source object
-     *   and will set the values to the target object
-     * (like a patch, with deep merge)
-     *
-     * (this also modifies the original target object in place)
-     */
-    static mergeObjects(target, source) {
-        if (typeof source === 'object') {
-            target ??= {};
-            for (const key in source) {
-                if (source[key] instanceof Object) {
-                    target[key] = this.mergeObjects(target[key], source[key]);
-                }
-                else if (Array.isArray(source[key])) {
-                    target[key] ??= [];
-                    source[key].forEach(item => {
-                        if (!target[key].includes(item) &&
-                            !(target[key].some(targetItem => this.sameObjects(item, targetItem)))) {
-                            target[key].push(item);
-                        }
-                    });
-                }
-                else {
-                    target[key] = source[key];
-                }
-            }
-        }
-        return target;
-    }
-    /**
-     * cleans the source object and merges it to the target object
-     *
-     * (this also modifies the original objects in place! (source AND target))
-     */
-    static patchObject(target, source) {
-        this.cleanObject(source);
-        return this.mergeObjects(target, source);
-    }
-    /**
-     * parses the JSON list, if it fails, it returns the answer as a single item in an array
-     *
-     * (uses {@link DyFM_safeParseJSON})
-     */
-    static safeParseList(textedJSON, disableErrorLog) {
-        const parsed = this.safeParseJSON(textedJSON, true);
-        if (Array.isArray(parsed)) {
-            return parsed;
-        }
-        else if (typeof parsed === 'object') {
-            if (!disableErrorLog) {
-                log_util_1.DyFM_Log.warn('DyFM_Object.safeParseList result is an object, returning its values', {
-                    parsed: parsed,
-                });
-            }
-            return Object.values(parsed);
-        }
-        else {
-            if (!disableErrorLog) {
-                log_util_1.DyFM_Log.warn('DyFM_Object.safeParseList result is not an array or object, returning it as a single item', {
-                    parsed: parsed,
-                });
-            }
-            return [parsed];
-        }
-    }
-    /**
-     * parses the JSON, if it fails, it returns { unparsableResult: textedJSON }
-     *
-     * (uses {@link DyFM_failableSafeParseJSON})
-     */
-    static safeParseJSON(textedJSON, disableErrorLog) {
-        try {
-            return this.failableSafeParseJSON(textedJSON);
-        }
-        catch (error) {
-            if (!disableErrorLog) {
-                log_util_1.DyFM_Log.error('Unable to parse JSON answer:', {
-                    unparsedJSON: textedJSON,
-                    error: error,
-                });
-            }
-            return { unparsableResult: textedJSON };
-        }
-    }
-    /**
-     * 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_old(textedJSON) {
-        if (!textedJSON) {
-            throw new Error(`No content provided to JSON parse ("${textedJSON}")`);
-        }
-        const match = textedJSON.match(/```json(.*)```/s);
-        // TODO; ez nem lesz az igazi, mert kiszedi a tartalmakból is a sortöréseket!!! (ugyan ez pár sorral lejjebb)
-        const cleanedTextedJSON = textedJSON.replaceAll('\n', '');
-        if (match) {
-            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(match[1].replaceAll('\n', ''));
-        }
-        else {
-            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(cleanedTextedJSON.replaceAll('```json', '').replaceAll('```', ''));
-        }
-    }
-    /**
-     * 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(textedJSON) {
-        if (!textedJSON) {
-            throw new Error(`No content provided to JSON parse ("${textedJSON}")`);
-        }
-        if (textedJSON.includes('```json')) {
-            // Extract content from code block, preserving newlines for error context
-            /* const extractedJson = match[1].trim(); */
-            const extractedJson = string_util_1.DyFM_String.multiBracketSplitDetailed(textedJSON, [
-                { opening: '```json', closing: '```' },
-                { opening: '{', closing: '}' },
-                { opening: '[', closing: ']' },
-            ], 1);
-            // Check if we have extracted content and handle undefined cases
-            if (extractedJson.length > 1 && extractedJson[1] && extractedJson[1].brackets?.opening === '```json') {
-                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(extractedJson[1].content);
-            }
-            else if (extractedJson.length > 0 && extractedJson[0]) {
-                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(extractedJson[0].content);
-            }
-            else {
-                // Fallback if extraction fails - use original text minus markdown wrapper
-                const cleanedText = textedJSON.replace(/```json\s*/, '').replace(/\s*```$/, '').trim();
-                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(cleanedText);
-            }
-        }
-        else {
-            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(textedJSON.trim());
-        }
-    }
-    /**
-     * Clone an object
-     * @param object - The object to clone
-     * @returns The cloned object
-     */
-    static clone(object) {
-        try {
-            return object ? JSON.parse(JSON.stringify(object)) : object;
-        }
-        catch (error) {
-            log_util_1.DyFM_Log.error('clone()' + this.defaultErrorMsg, error);
-            throw error;
-        }
-    }
-    static copy = this.clone;
-    /**
-     * Surface clone an object
-     * @param object - The object to surface clone
-     * @returns The surface cloned object
-     */
-    static surfaceClone(object) {
-        try {
-            const result = {};
-            Object.keys(object).forEach((key) => {
-                result[key] = object[key];
-            });
-            return result;
-        }
-        catch (error) {
-            log_util_1.DyFM_Log.error('surfaceClone()' + this.defaultErrorMsg, error);
-            throw error;
-        }
-    }
-    static surfaceCopy = this.surfaceClone;
-    /**
-     * Deep clone an object
-     * @param object - The object to deep clone
-     * @returns The deep cloned object
-     */
-    static deepClone(object) {
-        try {
-            const result = {};
-            if (!object) {
-                return result;
-            }
-            Object.keys(object).forEach((key) => {
-                if (typeof object[key] === 'object') {
-                    result[key] = this.deepClone(object[key]);
-                }
-                else if (Array.isArray(object[key])) {
-                    result[key] = object[key].map((item) => this.deepClone(item));
-                }
-                else {
-                    result[key] = object[key];
-                }
-            });
-            return result;
-        }
-        catch (error) {
-            log_util_1.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(objA, objB) {
-        try {
-            return JSON.stringify(objA) === JSON.stringify(objB);
-        }
-        catch (error) {
-            log_util_1.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(objA, objB) {
-        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) { */
-            log_util_1.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(objA, objB) {
-        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) {
-            log_util_1.DyFM_Log.error('sameObjects()' + this.defaultErrorMsg, error);
-            throw error;
-        }
-    }
-    /**
-     * compares the surface of two objects
-     * @param objA
-     * @param objB
-     * @returns
-     */
-    static sameObjectSurface(objA, objB) {
-        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, setTo) {
-        for (const key in setTo) {
-            if (setTo[key] != undefined) {
-                setOn[key] = setTo[key];
-            }
-        }
-    }
-    /**
-     * converts a JSONList to an array
-     * @param JSONList
-     * @returns
-     */
-    static JSONListify(JSONList) {
-        const result = [];
-        for (let i = 0; JSONList[i]; i++) {
-            result.push(JSONList[i]);
-        }
-        return result;
-    }
-    static cleanAssign(target, source) {
-        source = this.cleanObject(source);
-        return Object.assign(target, source);
-    }
-    static hardParseJSON(input) {
-        try {
-            return JSON.parse(input);
-        }
-        catch (error) {
-            try {
-                return this.failableSafeParseJSON(input);
-            }
-            catch (error) {
-                const result = this.safeParseJSON(input);
-                if (result.unparsableResult) {
-                    return result.unparsableResult;
-                }
-                return result;
-            }
-        }
-    }
-}
-exports.DyFM_Object = DyFM_Object;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_Object = void 0;
+const log_util_1 = require("./log.util");
+const json_error_helper_util_1 = require("./json-error-helper.util");
+const string_util_1 = require("./string.util");
+class DyFM_Object {
+    static 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
+     * @param objList object list to map
+     * @param paths string list of path etc.:
+     * ```ts
+     * [ [ 'first', 'sub', 'label' ], [ 'first', 'dif', 'name' ] ]
+     * ```
+     * will be...
+     * from
+     * ```ts
+     * {
+     *   first: {
+     *     sub: {
+     *       label: 'vlmi'
+     *     },
+     *     dif: {
+     *       name: 'asd'
+     *     }
+     *   }
+     * }[]
+     * ```
+     * to
+     * ```
+     * { label: 'vlmi', name: 'asd' }[]
+     * ```
+     * @returns remapped object list (the final obj will use the deepest keys)
+     */
+    static mapObjList(objList, paths) {
+        let newObjList = [...objList];
+        newObjList = newObjList.map((obj) => {
+            const newObj = {};
+            paths.forEach((path) => {
+                newObj[path[path.length - 1]] = this.getNestedData(obj, path);
+            });
+            return newObj;
+        });
+        return newObjList;
+    }
+    /**
+     * returns nested value from object
+     * @param parentObj data source object
+     * @param nestedDataKeys path of value as string list
+     * etc.: ['nestLvl1', 'nestLvl2', 'nestLvl3'] as parentObj.nestLvl1.nestLvl2.nestLvl3
+     * @returns data from object by path
+     */
+    static getNestedData(parentObj, nestedDataKeys) {
+        let newData = this.clone(parentObj); // {...parentObj};
+        nestedDataKeys.forEach((dk) => {
+            if (newData) {
+                newData = newData[dk];
+            }
+        });
+        return newData;
+    }
+    /**
+     * recursive function that nests data
+     * @param newData the object that that is needed to be updated
+     * @param nestKeys the path where the data should be updated
+     * @param dataToSet the actual value that will be setted
+     * @returns modified data
+     */
+    static nestData(parentObj, nestKeys, dataToSet) {
+        const newData = this.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;
+    }
+    /**
+     * recursive function that adds to nested data
+     * @param newData the object that that is needed to be updated
+     * @param nestKeys the path where the data should be updated
+     * @param dataToAdd the actual value that will be setted
+     * @returns modified data
+     */
+    static addToNestedData(parentObj, nestKeys, dataToAdd) {
+        const newData = this.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;
+    }
+    /**
+     * recursive function that pushes to nested data
+     * @param newData the object that that is needed to be updated
+     * @param nestKeys the path where the data should be updated
+     * @param dataToPush the actual value that will be setted
+     * @returns modified data
+     */
+    static pushToNestedData(parentObj, nestKeys, dataToPush) {
+        const newData = this.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]])) {
+                newData[nestKeys[0]].push(dataToPush);
+            }
+            else {
+                newData[nestKeys[0]] = [dataToPush];
+            }
+        }
+        return newData;
+    }
+    /**
+     * recursive function that nests data on recursive data structure etc.: xData: { ..., 'nestedListKey': xData[] }
+     * @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 seted on location
+     * @returns modified data
+     */
+    static nestRecursiveListedData(parentObj, nestedListKey, nestIndexes, dataToSet) {
+        const newData = this.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);
+        }
+        else {
+            newData[nestedListKey][nestIndexes[0]] = dataToSet;
+        }
+        return newData;
+    }
+    static 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(data, location = [('ROOT;' + data?.constructor?.name)], objs = []) {
+        if (!data || typeof data !== 'object') {
+            return data;
+        }
+        else if (objs.includes(data)) {
+            return 'CIRCULATION:' + location.join('.');
+        }
+        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) => {
+            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, location = [('ROOT;' + data?.constructor?.name)], objs = [], duplications = []) {
+        if (!data || typeof data !== 'object') {
+            return duplications;
+        }
+        else if (objs.includes(data)) {
+            duplications.push({
+                object: data,
+                pathsOfAllDuplications: location,
+            });
+        }
+        Object.keys(data).forEach((key) => {
+            this.findCirculations(data[key], [...location, key], [...objs, data], duplications);
+        });
+        return duplications;
+    }
+    /**
+     * removes all undefined (will keep all null, false, 0, '', NaN etc.)
+     *
+     * (not supports lists in lists!)
+     *
+     * (this also modifies the original object in place)
+     */
+    static safeCleanObject(obj) {
+        try {
+            return this.cleanObject(obj);
+        }
+        catch (error) {
+            log_util_1.DyFM_Log.error('Error cleaning object:', error);
+            return obj;
+        }
+    }
+    /**
+     * cleans the object, by removing all undefined values (but keeps all null, false, 0, '', NaN etc.)
+     * (this is a deep clean)
+     *
+     * (this also modifies the original object in place)
+     */
+    static cleanObject(obj, cleanings = []) {
+        if (!obj || typeof obj !== 'object' || cleanings.includes(obj)) {
+            return obj;
+        }
+        cleanings.push(obj);
+        Object.keys(obj).forEach((key) => {
+            if (obj[key] === undefined) {
+                delete obj[key];
+            }
+            else if (Array.isArray(obj[key])) {
+                obj[key].forEach((item) => {
+                    if (typeof item === 'object') {
+                        this.cleanObject(item, cleanings);
+                    }
+                });
+            }
+            else if (typeof obj[key] === 'object') {
+                this.cleanObject(obj[key], cleanings);
+            }
+        });
+        return obj;
+    }
+    /**
+     * merges two objects, if the target object is not an object, it will be replaced by the source object
+     * it will iterate through the source object
+     *   and will set the values to the target object
+     * (like a patch, with deep merge)
+     *
+     * (this also modifies the original target object in place)
+     */
+    static mergeObjects(target, source) {
+        if (typeof source === 'object') {
+            target ??= {};
+            for (const key in source) {
+                if (source[key] instanceof Object) {
+                    target[key] = this.mergeObjects(target[key], source[key]);
+                }
+                else if (Array.isArray(source[key])) {
+                    target[key] ??= [];
+                    source[key].forEach(item => {
+                        if (!target[key].includes(item) &&
+                            !(target[key].some(targetItem => this.sameObjects(item, targetItem)))) {
+                            target[key].push(item);
+                        }
+                    });
+                }
+                else {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    }
+    /**
+     * cleans the source object and merges it to the target object
+     *
+     * (this also modifies the original objects in place! (source AND target))
+     */
+    static patchObject(target, source) {
+        this.cleanObject(source);
+        return this.mergeObjects(target, source);
+    }
+    /**
+     * parses the JSON list, if it fails, it returns the answer as a single item in an array
+     *
+     * (uses {@link DyFM_safeParseJSON})
+     */
+    static safeParseList(textedJSON, disableErrorLog) {
+        const parsed = this.safeParseJSON(textedJSON, true);
+        if (Array.isArray(parsed)) {
+            return parsed;
+        }
+        else if (typeof parsed === 'object') {
+            if (!disableErrorLog) {
+                log_util_1.DyFM_Log.warn('DyFM_Object.safeParseList result is an object, returning its values', {
+                    parsed: parsed,
+                });
+            }
+            return Object.values(parsed);
+        }
+        else {
+            if (!disableErrorLog) {
+                log_util_1.DyFM_Log.warn('DyFM_Object.safeParseList result is not an array or object, returning it as a single item', {
+                    parsed: parsed,
+                });
+            }
+            return [parsed];
+        }
+    }
+    /**
+     * parses the JSON, if it fails, it returns { unparsableResult: textedJSON }
+     *
+     * (uses {@link DyFM_failableSafeParseJSON})
+     */
+    static safeParseJSON(textedJSON, disableErrorLog) {
+        try {
+            return this.failableSafeParseJSON(textedJSON);
+        }
+        catch (error) {
+            if (!disableErrorLog) {
+                log_util_1.DyFM_Log.error('Unable to parse JSON answer:', {
+                    unparsedJSON: textedJSON,
+                    error: error,
+                });
+            }
+            return { unparsableResult: textedJSON };
+        }
+    }
+    /**
+     * 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_old(textedJSON) {
+        if (!textedJSON) {
+            throw new Error(`No content provided to JSON parse ("${textedJSON}")`);
+        }
+        const match = textedJSON.match(/```json(.*)```/s);
+        // TODO; ez nem lesz az igazi, mert kiszedi a tartalmakból is a sortöréseket!!! (ugyan ez pár sorral lejjebb)
+        const cleanedTextedJSON = textedJSON.replaceAll('\n', '');
+        if (match) {
+            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(match[1].replaceAll('\n', ''));
+        }
+        else {
+            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(cleanedTextedJSON.replaceAll('```json', '').replaceAll('```', ''));
+        }
+    }
+    /**
+     * 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(textedJSON) {
+        if (!textedJSON) {
+            throw new Error(`No content provided to JSON parse ("${textedJSON}")`);
+        }
+        if (textedJSON.includes('```json')) {
+            // Extract content from code block, preserving newlines for error context
+            /* const extractedJson = match[1].trim(); */
+            const extractedJson = string_util_1.DyFM_String.multiBracketSplitDetailed(textedJSON, [
+                { opening: '```json', closing: '```' },
+                { opening: '{', closing: '}' },
+                { opening: '[', closing: ']' },
+            ], 1);
+            // Check if we have extracted content and handle undefined cases
+            if (extractedJson.length > 1 && extractedJson[1] && extractedJson[1].brackets?.opening === '```json') {
+                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(extractedJson[1].content);
+            }
+            else if (extractedJson.length > 0 && extractedJson[0]) {
+                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(extractedJson[0].content);
+            }
+            else {
+                // Fallback if extraction fails - use original text minus markdown wrapper
+                const cleanedText = textedJSON.replace(/```json\s*/, '').replace(/\s*```$/, '').trim();
+                return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(cleanedText);
+            }
+        }
+        else {
+            return json_error_helper_util_1.DyFM_JsonErrorHelper.parseJsonWithEnhancedError(textedJSON.trim());
+        }
+    }
+    /**
+     * Clone an object
+     * @param object - The object to clone
+     * @returns The cloned object
+     */
+    static clone(object) {
+        try {
+            return object ? JSON.parse(JSON.stringify(object)) : object;
+        }
+        catch (error) {
+            log_util_1.DyFM_Log.error('clone()' + this.defaultErrorMsg, error);
+            throw error;
+        }
+    }
+    static copy = this.clone;
+    /**
+     * Surface clone an object
+     * @param object - The object to surface clone
+     * @returns The surface cloned object
+     */
+    static surfaceClone(object) {
+        try {
+            const result = {};
+            Object.keys(object).forEach((key) => {
+                result[key] = object[key];
+            });
+            return result;
+        }
+        catch (error) {
+            log_util_1.DyFM_Log.error('surfaceClone()' + this.defaultErrorMsg, error);
+            throw error;
+        }
+    }
+    static surfaceCopy = this.surfaceClone;
+    /**
+     * Deep clone an object
+     * @param object - The object to deep clone
+     * @returns The deep cloned object
+     */
+    static deepClone(object) {
+        try {
+            const result = {};
+            if (!object) {
+                return result;
+            }
+            Object.keys(object).forEach((key) => {
+                if (typeof object[key] === 'object') {
+                    result[key] = this.deepClone(object[key]);
+                }
+                else if (Array.isArray(object[key])) {
+                    result[key] = object[key].map((item) => this.deepClone(item));
+                }
+                else {
+                    result[key] = object[key];
+                }
+            });
+            return result;
+        }
+        catch (error) {
+            log_util_1.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(objA, objB) {
+        try {
+            return JSON.stringify(objA) === JSON.stringify(objB);
+        }
+        catch (error) {
+            log_util_1.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(objA, objB) {
+        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) { */
+            log_util_1.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(objA, objB) {
+        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) {
+            log_util_1.DyFM_Log.error('sameObjects()' + this.defaultErrorMsg, error);
+            throw error;
+        }
+    }
+    /**
+     * compares the surface of two objects
+     * @param objA
+     * @param objB
+     * @returns
+     */
+    static sameObjectSurface(objA, objB) {
+        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, setTo) {
+        for (const key in setTo) {
+            if (setTo[key] != undefined) {
+                setOn[key] = setTo[key];
+            }
+        }
+    }
+    /**
+     * converts a JSONList to an array
+     * @param JSONList
+     * @returns
+     */
+    static JSONListify(JSONList) {
+        const result = [];
+        for (let i = 0; JSONList[i]; i++) {
+            result.push(JSONList[i]);
+        }
+        return result;
+    }
+    static cleanAssign(target, source) {
+        source = this.cleanObject(source);
+        return Object.assign(target, source);
+    }
+    static hardParseJSON(input) {
+        try {
+            return JSON.parse(input);
+        }
+        catch (error) {
+            try {
+                return this.failableSafeParseJSON(input);
+            }
+            catch (error) {
+                const result = this.safeParseJSON(input);
+                if (result.unparsableResult) {
+                    return result.unparsableResult;
+                }
+                return result;
+            }
+        }
+    }
+}
+exports.DyFM_Object = DyFM_Object;
 //# sourceMappingURL=object.util.js.map