@cofondateurauchomage/libs 1.1.64 → 1.1.65

package/build/regex.d.ts

@@ -4,6 +4,8 @@ export declare const RGX: {
     };
     Email: {
         regex: RegExp;
+        pattern: string;
+        message: string;
     };
     Linkedin: {
         regex: RegExp;

package/build/regex.js

@@ -15,6 +15,8 @@ exports.RGX = {
     },
     Email: {
         regex: regex.email,
+        pattern: pattern(regex.email),
+        message: `Veuillez entrer une adresse email valide.`,
     },
     Linkedin: {
         regex: regex.linkedin,

package/build/utils/objectUtils.d.ts

@@ -8,3 +8,18 @@ export declare function pickObject<T extends object, K extends keyof T>(obj: T,
 export declare function omitObject<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
 export declare function typedKeys<T extends object>(obj: T): Array<keyof T>;
 export declare function typedObjectEntries<T extends object>(obj: T): Array<[keyof T, T[keyof T]]>;
+export declare function isObject(x: unknown): x is object;
+type IsEmpty<T> = T extends undefined | null ? true : T extends "" ? true : T extends [] ? true : T extends Record<string, never> ? true : false;
+type Cleaned<T> = {
+    [K in keyof T as IsEmpty<T[K]> extends true ? never : K]: Exclude<T[K], undefined | null | "">;
+};
+/**
+ * Permet de nettoyer un objet en supprimant les clés qui ont une valeur :
+ * '' / undefined / null / [] / {}
+ * @option recursive - si true, les objets sont nettoyés recursivement
+ */
+export declare function cleanObject<T extends object>(obj: T, options?: {
+    recursive?: boolean;
+}): Cleaned<T>;
+export default function deepEqual<T>(obj1: T, obj2: T): boolean;
+export {};

package/build/utils/objectUtils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typedObjectEntries = exports.typedKeys = exports.omitObject = exports.pickObject = void 0;
+exports.cleanObject = exports.isObject = exports.typedObjectEntries = exports.typedKeys = exports.omitObject = exports.pickObject = void 0;
+const arrayUtils_1 = require("./arrayUtils");
 /**
  * Pick certaines clés d'un objet
  */
@@ -28,3 +29,52 @@ function typedObjectEntries(obj) {
     return Object.entries(obj);
 }
 exports.typedObjectEntries = typedObjectEntries;
+function isObject(x) {
+    return typeof x === "object" && !Array.isArray(x) && x !== null;
+}
+exports.isObject = isObject;
+/**
+ * Permet de nettoyer un objet en supprimant les clés qui ont une valeur :
+ * '' / undefined / null / [] / {}
+ * @option recursive - si true, les objets sont nettoyés recursivement
+ */
+function cleanObject(obj, options) {
+    const result = {};
+    for (const [key, value] of typedObjectEntries(obj)) {
+        const cleanedValue = isObject(value) && options?.recursive
+            ? cleanObject(value, { recursive: true })
+            : value;
+        if (cleanedValue !== "" &&
+            cleanedValue !== undefined &&
+            cleanedValue !== null &&
+            (!Array.isArray(cleanedValue) || (0, arrayUtils_1.compact)(cleanedValue).length > 0) &&
+            (!isObject(value) || Object.keys(cleanedValue).length > 0)) {
+            result[key] = cleanedValue;
+        }
+    }
+    return result;
+}
+exports.cleanObject = cleanObject;
+function deepEqual(obj1, obj2) {
+    if (obj1 === obj2) {
+        return true;
+    }
+    if (obj1 && typeof obj1 === "object" && obj2 && typeof obj2 === "object") {
+        const keys1 = typedKeys(obj1);
+        const keys2 = typedKeys(obj2);
+        if (keys1.length !== keys2.length) {
+            return false;
+        }
+        for (const key of keys1) {
+            if (!keys2.includes(key)) {
+                return false;
+            }
+            if (!deepEqual(obj1[key], obj2[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+exports.default = deepEqual;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofondateurauchomage/libs",
-  "version": "1.1.64",
+  "version": "1.1.65",
   "description": "",
   "main": "build/index",
   "scripts": {