@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_collections/utils/object.util.d.ts

@@ -1,222 +1,222 @@
-export interface DyFM_Object_ParseResult {
-    unparsableResult: string;
-}
-export declare class DyFM_Object {
-    static readonly defaultErrorMsg: string;
-    /**
-     * 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: object[], paths: string[][]): object[];
-    /**
-     * 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: object, nestedDataKeys: string[]): any;
-    /**
-     * 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: object, nestKeys: string[], dataToSet: any): object;
-    /**
-     * 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: object, nestKeys: string[], dataToAdd: any): object;
-    /**
-     * 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: object, nestKeys: string[], dataToPush: any): object;
-    /**
-     * 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<T>(parentObj: T, nestedListKey: string, nestIndexes: number[], dataToSet: any): T;
-    static readonly removeCirculation: typeof DyFM_Object.resolveCirculation;
-    /**
-     * THIS STILL NOT WORKING AS IT SHOULD
-     *
-     * recursive function that returns mutated data structure,
-     * with locations at which circular references are found
-     */
-    static resolveCirculation<T>(data: T, location?: string[], objs?: any[]): any;
-    /**
-     * looks for circular references in object
-     * returns duplicated object's all location paths and the object itself
-     *
-     *  {
-     *    object: any,
-     *    pathsOfAllDuplications: string[],
-     *  }[]
-     *
-     * paths are in a single string, separated by '.'
-     */
-    static findCirculations(data: any, location?: string[], objs?: any[], duplications?: {
-        object: any;
-        pathsOfAllDuplications: string[];
-    }[]): {
-        object: any;
-        pathsOfAllDuplications: string[];
-    }[];
-    /**
-     * 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<T>(obj: T): T;
-    /**
-     * 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<T>(obj: T, cleanings?: any[]): T;
-    /**
-     * 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<T>(target: T, source: T): T;
-    /**
-     * cleans the source object and merges it to the target object
-     *
-     * (this also modifies the original objects in place! (source AND target))
-     */
-    static patchObject<T>(target: T, source: T): T;
-    /**
-     * parses the JSON list, if it fails, it returns the answer as a single item in an array
-     *
-     * (uses {@link DyFM_safeParseJSON})
-     */
-    static safeParseList<T extends Array<any>>(textedJSON: string, disableErrorLog?: boolean): T;
-    /**
-     * parses the JSON, if it fails, it returns { unparsableResult: textedJSON }
-     *
-     * (uses {@link DyFM_failableSafeParseJSON})
-     */
-    static safeParseJSON<T = any>(textedJSON: string, disableErrorLog?: boolean): T | DyFM_Object_ParseResult;
-    /**
-     * 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<T = any>(textedJSON: string): T;
-    /**
-     * parses the JSON, if it fails, it throws an error
-     * (also will extract the JSON from "```json ... ```" wrapper)
-     * Uses enhanced error reporting with line context
-     */
-    static failableSafeParseJSON<T = any>(textedJSON: string): T;
-    /**
-     * Clone an object
-     * @param object - The object to clone
-     * @returns The cloned object
-     */
-    static clone<T>(object: T): T;
-    static readonly copy: typeof this.clone;
-    /**
-     * Surface clone an object
-     * @param object - The object to surface clone
-     * @returns The surface cloned object
-     */
-    static surfaceClone<T extends Record<string, any>>(object: T): T;
-    static readonly surfaceCopy: typeof this.surfaceClone;
-    /**
-     * Deep clone an object
-     * @param object - The object to deep clone
-     * @returns The deep cloned object
-     */
-    static deepClone<T extends Record<string, any>>(object: T): T;
-    /**
-     * A simple object comparison function that uses JSON.stringify() to compare objects.
-     *
-     * We experienced that sameObjects() function is not working properly for cases when
-     * deleting a key from the objects (to prevent strict results).
-     * So, we created orderedSameObject() function to prevent that issue.
-     * But be aware that, that function is not as fast as sameObjects() function.
-     */
-    static sameObjects<T>(objA: T, objB: T): boolean;
-    /**
-     * We experienced that sameObjects() function is not working properly for cases when
-     * deleting a key from the objects (to prevent strict results).
-     *
-     * This function is created to prevent that issue.
-     * But be aware that this function is not as fast as sameObjects() function.
-     */
-    static orderedSameObject<T>(objA: T, objB: T): boolean;
-    /**
-     * We experienced that sameObjects() function is not working properly for cases when
-     * deleting a key from the objects (to prevent strict results).
-     *
-     * This function is created to prevent that issue.
-     * But be aware that this function is not as fast as sameObjects() function.
-     */
-    static orderedSameObject2<T>(objA: T, objB: T): boolean;
-    /**
-     * compares the surface of two objects
-     * @param objA
-     * @param objB
-     * @returns
-     */
-    static sameObjectSurface<T>(objA: T, objB: T): boolean;
-    /**
-     * sets values if its existing on To, even if its null (but if undefined)
-     * @param setOn
-     * @param setTo
-     */
-    static setExistingValuesOnly(setOn: any, setTo: any): void;
-    /**
-     * converts a JSONList to an array
-     * @param JSONList
-     * @returns
-     */
-    static JSONListify<T>(JSONList: any): T[];
-    static cleanAssign<T>(target: T, source: T): T;
-    static hardParseJSON<T>(input: string): T | string;
-}
+export interface DyFM_Object_ParseResult {
+    unparsableResult: string;
+}
+export declare class DyFM_Object {
+    static readonly defaultErrorMsg: string;
+    /**
+     * 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: object[], paths: string[][]): object[];
+    /**
+     * 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: object, nestedDataKeys: string[]): any;
+    /**
+     * 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: object, nestKeys: string[], dataToSet: any): object;
+    /**
+     * 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: object, nestKeys: string[], dataToAdd: any): object;
+    /**
+     * 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: object, nestKeys: string[], dataToPush: any): object;
+    /**
+     * 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<T>(parentObj: T, nestedListKey: string, nestIndexes: number[], dataToSet: any): T;
+    static readonly removeCirculation: typeof DyFM_Object.resolveCirculation;
+    /**
+     * THIS STILL NOT WORKING AS IT SHOULD
+     *
+     * recursive function that returns mutated data structure,
+     * with locations at which circular references are found
+     */
+    static resolveCirculation<T>(data: T, location?: string[], objs?: any[]): any;
+    /**
+     * looks for circular references in object
+     * returns duplicated object's all location paths and the object itself
+     *
+     *  {
+     *    object: any,
+     *    pathsOfAllDuplications: string[],
+     *  }[]
+     *
+     * paths are in a single string, separated by '.'
+     */
+    static findCirculations(data: any, location?: string[], objs?: any[], duplications?: {
+        object: any;
+        pathsOfAllDuplications: string[];
+    }[]): {
+        object: any;
+        pathsOfAllDuplications: string[];
+    }[];
+    /**
+     * 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<T>(obj: T): T;
+    /**
+     * 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<T>(obj: T, cleanings?: any[]): T;
+    /**
+     * 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<T>(target: T, source: T): T;
+    /**
+     * cleans the source object and merges it to the target object
+     *
+     * (this also modifies the original objects in place! (source AND target))
+     */
+    static patchObject<T>(target: T, source: T): T;
+    /**
+     * parses the JSON list, if it fails, it returns the answer as a single item in an array
+     *
+     * (uses {@link DyFM_safeParseJSON})
+     */
+    static safeParseList<T extends Array<any>>(textedJSON: string, disableErrorLog?: boolean): T;
+    /**
+     * parses the JSON, if it fails, it returns { unparsableResult: textedJSON }
+     *
+     * (uses {@link DyFM_failableSafeParseJSON})
+     */
+    static safeParseJSON<T = any>(textedJSON: string, disableErrorLog?: boolean): T | DyFM_Object_ParseResult;
+    /**
+     * 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<T = any>(textedJSON: string): T;
+    /**
+     * parses the JSON, if it fails, it throws an error
+     * (also will extract the JSON from "```json ... ```" wrapper)
+     * Uses enhanced error reporting with line context
+     */
+    static failableSafeParseJSON<T = any>(textedJSON: string): T;
+    /**
+     * Clone an object
+     * @param object - The object to clone
+     * @returns The cloned object
+     */
+    static clone<T>(object: T): T;
+    static readonly copy: typeof this.clone;
+    /**
+     * Surface clone an object
+     * @param object - The object to surface clone
+     * @returns The surface cloned object
+     */
+    static surfaceClone<T extends Record<string, any>>(object: T): T;
+    static readonly surfaceCopy: typeof this.surfaceClone;
+    /**
+     * Deep clone an object
+     * @param object - The object to deep clone
+     * @returns The deep cloned object
+     */
+    static deepClone<T extends Record<string, any>>(object: T): T;
+    /**
+     * A simple object comparison function that uses JSON.stringify() to compare objects.
+     *
+     * We experienced that sameObjects() function is not working properly for cases when
+     * deleting a key from the objects (to prevent strict results).
+     * So, we created orderedSameObject() function to prevent that issue.
+     * But be aware that, that function is not as fast as sameObjects() function.
+     */
+    static sameObjects<T>(objA: T, objB: T): boolean;
+    /**
+     * We experienced that sameObjects() function is not working properly for cases when
+     * deleting a key from the objects (to prevent strict results).
+     *
+     * This function is created to prevent that issue.
+     * But be aware that this function is not as fast as sameObjects() function.
+     */
+    static orderedSameObject<T>(objA: T, objB: T): boolean;
+    /**
+     * We experienced that sameObjects() function is not working properly for cases when
+     * deleting a key from the objects (to prevent strict results).
+     *
+     * This function is created to prevent that issue.
+     * But be aware that this function is not as fast as sameObjects() function.
+     */
+    static orderedSameObject2<T>(objA: T, objB: T): boolean;
+    /**
+     * compares the surface of two objects
+     * @param objA
+     * @param objB
+     * @returns
+     */
+    static sameObjectSurface<T>(objA: T, objB: T): boolean;
+    /**
+     * sets values if its existing on To, even if its null (but if undefined)
+     * @param setOn
+     * @param setTo
+     */
+    static setExistingValuesOnly(setOn: any, setTo: any): void;
+    /**
+     * converts a JSONList to an array
+     * @param JSONList
+     * @returns
+     */
+    static JSONListify<T>(JSONList: any): T[];
+    static cleanAssign<T>(target: T, source: T): T;
+    static hardParseJSON<T>(input: string): T | string;
+}
 //# sourceMappingURL=object.util.d.ts.map