valia

<img src="https://github.com/user-attachments/assets/ea937a53-9b80-43d7-93ac-81538d9526f8" align="center" alt="VALIA logo" /> <img src="https://img.shields.io/npm/v/valia.svg?style=flat" align="center" alt="NPM version" /> <h3 align="center">Bibliothèque de validation pour TypeScript et JavaScript</h3> 🔌 S’intègre naturellement à vos projets, qu’ils soient front-end ou back-end, et permet de définir des schémas de manière intuitive tout en favorisant leur réutilisation. 💡 Pensée pour allier simplicité et puissance, elle propose des fonctionnalités avancées comme l’inférence de types, ainsi que des validateurs standards tels que isEmail, isUuid ou isIp. ## Table des matières - [Schema](#schema) - [Instances](#instances) - [Formats](#formats) - [Exemples](#exemples) - [Testers](#testers) - [Object](#object) - [String](#string-1) - [Helpers](#helpers) - [Object](#object-1) - [String](#string-2) ## Installation ``` > npm install valia ``` ```ts import { Schema } from 'valia'; const userSchema = new Schema({ type: "object", shape: { name: { type: "string" }, role: { type: "string", literal: ["WORKER", "CUSTOMER"] } } }); let data = { name: "Alice", role: "WORKER" }; if (userSchema.validate(data)) { console.log(data.name, data.role); } ``` ```ts import type { SchemaInfer } from 'valia'; type User = SchemaInfer<typeof userSchema>; ``` # Schema ## Instances ### Schema <ul> <li> criteria Propriété représentant la racine des noeuds de critères. </li> <li> validate(data) Methode qui valide les données fournies selon les critères et retourne un booléen. Cette méthode utilise la <a href="https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates"> prédiction de types ↗</a>. </li> <li> evaluate(data) Methode qui valide les données fournies selon les critères et retourne un objet avec les propriétés suivantes : <ul> <li> success: Un boolean qui indique si la validation a réussi. </li> <li> rejection: Instance de SchemaDataRejection si les données sont rejetées sinon null. </li> <li> admission: Instance de SchemaDataAdmission si les données sont admises sinon null. </li> </ul> </li> </ul> ### SchemaException <ul> <li> message Message décrivant le problème rencontré. </li> </ul> ### SchemaNodeException <ul> <li> code Code de l'exception. </li> <li> message Message décrivant le problème rencontré. </li> <li> node Noeud noeud lié à l'exception. </li> <li> nodePath Chemin du noeud noeud lié à l'exception. <ul> <li> explicit: Tableau représentant le chemin vers le noeud dans l'arbre des critères. </li> <li> implicit: Tableau représentant le chemin virtuel vers les données représentées par noeud. </li> </ul> </li> </ul> ### SchemaDataRejection <ul> <li> rootData Racine des données à valider. </li> <li> rootNode Noeud racine utilisé pour la validation. </li> <li> rootLabel Label du noeud racine utilisé pour la validation ou undefined si le label n'a pas été défini. </li> <li> data Données rejetées. </li> <li> code Code lié au rejet. </li> <li> node Noeud lié au rejet. </li> <li> nodePath Chemin du noeud noeud lié au rejet. <ul> <li> explicit: Tableau représentant le chemin vers le noeud dans l'arbre des critères. </li> <li> implicit: Tableau représentant le chemin virtuel vers les données représentées par noeud. </li> </ul> </li> <li> label Label défini sur le noeud lié au rejet ou undefined si le label n'a pas été défini. </li> <li> message Message défini sur le noeud lié au rejet ou undefined si le message n'a pas été défini. </li> </ul> ### SchemaDataAdmission <ul> <li> data Racine des données valider. </li> <li> node Noeud racine utilisé pour la validation. </li> <li> label Label du noeud racine utilisé pour la validation ou undefined si le label n'a pas été défini. </li> </ul> ## Formats [Number](#number) • [String](#string) • [Boolean](#boolean) • [Object](#object) • [Array](#array) • [Function](#function) • [Symbol](#symbol) • [Union](#union) • [Null](#null) • [Undefined](#undefined) Les formats représentent les noeuds de critères qui pourront être utilisés dans les schémas. *L'ordre des propriétés décrites pour chaque formats respecte l'ordre de validation.* ### Global #### **Propriétés :** <ul> <li> label? Une chaine de caratéres permetant d'idantifié le noeud, celle-ci vous sera retournée dans les instance de SchemaDataRejection et SchemaNodeException. </li> <li> message? <ul> <li>string: Chaîne de caractères qui sera disponible dans l'instance de SchemaDataRejection.</li> <li>function: Fonction qui doit renvoyer une chaîne de caractères qui sera disponible dans l'instance de SchemaDataRejection.</li> </ul> </li> </ul> ### Number #### **Propriétés :** <ul> <li> type: "number" </li> <li> min? Nombre minimale. </li> <li> max? Nombre maximale. </li> <li> literal? <ul> <li>string: Restreint la valeur à une seul nombre valide.</li> <li>array: Restreint la valeur avec un tableau dont les items représentent les nombres valides.</li> <li>object: Restreint la valeur avec un objet dont les valeurs représentent les nombres valides.</li> </ul> </li> <li> custom(value)? Fonction de validation custom qui reçoit la valeur en paramètre et doit renvoyer un booléen indiquant si la celle-ci est valide. </li> </ul> #### **Exemples :** **Validé n'importe quel nombre** ```ts const schema = new Schema({ type: "number" }); ✅ schema.validate(0); ✅ schema.validate(10); ✅ schema.validate(-10); ``` **Valide des nombres qui appartiennent à une plage spécifique** ```ts const schema = new Schema({ type: "number", min: 0, max: 10 }); ✅ schema.validate(0); ✅ schema.validate(10); ❌ schema.validate(-1); ❌ schema.validate(-10); ``` **Validé un nombre spécifique** ```ts const schema = new Schema({ type: "number", literal: 141 }); ✅ schema.validate(141); ❌ schema.validate(-1); ❌ schema.validate(-10); ``` **Validé des nombres spécifique avec un tableau** ```ts const schema = new Schema({ type: "number", literal: [141, 282] }); ✅ schema.validate(141); ✅ schema.validate(282); ❌ schema.validate(0); ❌ schema.validate(100); ❌ schema.validate(200); ``` ### String #### **Propriétés :** <ul> <li> type: "string" </li> <li> min? Longueur minimale de la chaîne de caractères. </li> <li> max? Longueur maximale de la chaîne de caractères. </li> <li> regex? Une expression régulière fournie sous forme d'objet (RegExp). </li> <li> literal? <ul> <li>string: Restreint la valeur à une seul chaîne de caractères valides.</li> <li>array: Restreint la valeur avec un tableau où les items représentent les chaîne de caractères valides.</li> <li>object: Restreint la valeur avec un objet où les valeurs représentent les chaîne de caractères valides.</li> </ul> </li> <li> constraint? Un objet dont les clés correspondent à des noms de testeurs de chaîne et dont les valeurs possible sont : <ul> <li>boolean : active ou désactive le testeur.</li> <li>objet : le testeur est activé avec les options spécifiés dans l'objet.</li> </ul> La valeur sera considérée comme valide si au moins un testeur renvoie un résultat positif. </li> <li> custom(value)? Fonction de validation custom qui reçoit la valeur en paramètre et doit renvoyer un booléen indiquant si la celle-ci est valide. </li> </ul> #### **Exemples :** **Validé n'importe quel chaîne de caractères** ```ts const schema = new Schema({ type: "string" }); ✅ schema.validate(""); ✅ schema.validate("abc"); ``` **Validé des chaînes de caractères ayant une longueur spécifique** ```ts const schema = new Schema({ type: "string", min: 3, max: 3 }); ✅ schema.validate("abc"); ❌ schema.validate(""); ❌ schema.validate("a"); ❌ schema.validate("abcd"); ``` **Validé des chaînes de caractères avec une expression régulière** ```ts const schema = new Schema({ type: "string", regex: /^#[a-fA-F0-9]{6}$/ }); ✅ schema.validate("#000000"); ✅ schema.validate("#FFFFFF"); ❌ schema.validate(""); ❌ schema.validate("#000"); ❌ schema.validate("#FFF"); ``` **Validé une chaîne de caractères spécifique** ```ts const schema = new Schema({ type: "string", literal: "ABC" }); ✅ schema.validate("ABC"); ❌ schema.validate(""); ❌ schema.validate("a"); ❌ schema.validate("abc"); ``` **Validé des chaînes de caractères spécifique avec un tableau** ```ts const schema = new Schema({ type: "string", literal: ["ABC", "XYZ"] }); ✅ schema.validate("ABC"); ✅ schema.validate("XYZ"); ❌ schema.validate(""); ❌ schema.validate("a"); ❌ schema.validate("abc"); ``` **Validé des chaînes de caractères avec un testeur de chaîne** ```ts const schema = new Schema({ type: "string", constraint: { idIp: { cidr: true } } }); ✅ schema.validate("127.0.0.1/24"); ❌ schema.validate(""); ❌ schema.validate("127.0.0.1"); ``` **Validé des chaînes de caractères avec plusieurs testeurs de chaîne** ```ts const schema = new Schema({ type: "string", constraint: { isEmail: true, idIp: { cidr: true } } }); ✅ schema.validate("foo@bar"); ✅ schema.validate("127.0.0.1/24"); ❌ schema.validate(""); ❌ schema.validate("foo@"); ❌ schema.validate("127.0.0.1"); ``` ### Boolean #### **Propriétés :** <ul> <li> type: "boolean" </li> <li> literal? Restreint la valeur à un seul état de booléen valide. </li> <li> custom(value)? Fonction de validation custom qui reçoit la valeur en paramètre et doit renvoyer un booléen indiquant si la celle-ci est valide. </li> </ul> #### **Exemples :** **Validé n'importe quel booléen** ```ts const schema = new Schema({ type: "boolean" }); ✅ schema.validate(true); ✅ schema.validate(false); ❌ schema.validate(""); ❌ schema.validate({}); ``` **Validé un booléen avec un état spécifique** ```ts const schema = new Schema({ type: "boolean", literal: true }); ✅ schema.validate(true); ❌ schema.validate(""); ❌ schema.validate({}); ❌ schema.validate(false); ``` ### Object #### **Propriétés :** <ul> <li> type: "object" </li> <li> nature? — (Default: "STANDARD") <ul> <li> "STANDARD": Accepte toute valeur de type object, c’est-à-dire tout ce pour quoi typeof value === "object". </li> <li> "PLAIN": Accepte uniquement les objets dont le prototype est soit Object.prototype (comme les objets créés via {}), soit null (créés via Object.create(null)). </li> </ul> </li> <li> min? Nombre de propriétés minimum. </li> <li> max? Nombre de propriétés maximun. </li> <li> shape? Un objet dont les clés sont de type string ou symbol et dont les valeurs sont des noeuds de critères. Représente des propriétés fixes que l'objet doit satisfaire. </li> <li> optional? — (Default: false | Utilisable seulement si shape est défini) <ul> <li> boolean <ul> <li>true: Toutes les propriétés définies dans l'objet shape sont optionnelles.</li> <li>false: Toutes les propriétés définies dans l'objet shape sont obligatoires.</li> </ul> </li> <li> array Un tableau dont les éléments sont des clés de l’objet shape qui sont optionnelles. </li> </ul> </li> <li> keys? Noeud de critères que les clés de l'objet doivent satisfaire. Les clés définies dans l'objet shape ne sont pas affectées. </li> <li> values? Noeud de critères que les valeurs doivent satisfaire. Les valeurs définies dans l'objet shape ne sont pas affectées. </li> </ul> #### **Exemples :** **Validé n'importe quel objet** ```ts const schema = new Schema({ type: "object" }); ✅ schema.validate({}); ✅ schema.validate([]); ✅ schema.validate(new Date()); ✅ schema.validate(Object.create(null)); ❌ schema.validate(""); ``` **Validé un objet de nature simple** ```ts const schema = new Schema({ type: "object", nature: "PLAIN" }); ✅ schema.validate({}); ✅ schema.validate(Object.create(null)); ❌ schema.validate(""); ❌ schema.validate([]); ❌ schema.validate(new Date()); ``` **Validé un objet avec des propriétés fixes** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" } } }); ✅ schema.validate({ foo: "x", bar: "x" }); ❌ schema.validate({}); ❌ schema.validate({ foo: "x" }); ❌ schema.validate({ bar: "x" }); ❌ schema.validate({ foo: "x", bar: "x", a: "" }); ``` **Validé un objet et un sous-objet de propriétés fixes** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" }, baz: { foo: { type: "number" }, bar: { type: "number" } } } }); ✅ schema.validate({ foo: "x", bar: "x", baz: { foo: 0, bar: 0 } }); ❌ schema.validate({}); ❌ schema.validate({ foo: "x" }); ❌ schema.validate({ foo: "x", bar: "x" }); ❌ schema.validate({ foo: "x", bar: "x", baz: {} }); ❌ schema.validate({ foo: "x", bar: "x", baz: { foo: 0 } }); ``` **Validé un objet avec des propriétés facultatives** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" } }, optional: true }); ✅ schema.validate({}); ✅ schema.validate({ foo: "x" }); ✅ schema.validate({ bar: "x" }); ✅ schema.validate({ foo: "x", bar: "x" }); ❌ schema.validate({ foo: "x", bar: "x", a: "x" }); ``` **Validé un objet avec une propriété fixe et une propriété facultative** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" } }, optional: ["bar"] }); ✅ schema.validate({ foo: "x" }); ✅ schema.validate({ foo: "x", bar: "x" }); ❌ schema.validate({}); ❌ schema.validate({ bar: "x" }); ❌ schema.validate({ foo: "x", bar: "x", a: "x" }); ``` **Validé un objet avec des propriétés fixes et des propriétés dynamiques libres** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" } }, values: { type: "unknown" } }); ✅ schema.validate({ foo: "x", bar: "x" }); ✅ schema.validate({ foo: "x", bar: "x", a: "x", b: 0 }); ❌ schema.validate({}); ❌ schema.validate({ bar: "x" }); ❌ schema.validate({ foo: "x" }); ``` **Validé un objet avec des propriétés fixes et des propriétés dynamiques contraintes** ```ts const schema = new Schema({ type: "object", shape: { foo: { type: "string" }, bar: { type: "string" } }, keys: { type: "string" }, values: { type: "number" } }); ✅ schema.validate({ foo: "x", bar: "x" }); ✅ schema.validate({ foo: "x", bar: "x", a: 0 }); ✅ schema.validate({ foo: "x", bar: "x", a: 0, b: 0 }); ❌ schema.validate({}); ❌ schema.validate({ foo: "x" }); ❌ schema.validate({ bar: "x" }); ❌ schema.validate({ foo: "x", bar: "x", a: "x", b: 0 }); ``` **Validé un objet avec des propriétés dynamiques contraintes** ```ts const schema = new Schema({ type: "object", keys: { type: "string" }, values: { type: "string" } }); ✅ schema.validate({}); ✅ schema.validate({ a: "x" }); ✅ schema.validate({ a: "x", b: "x" }); ❌ schema.validate({ a: 0 }); ❌ schema.validate({ a: "x", b: 0 }); ``` ### Array #### **Propriétés :** <ul> <li> type: "array" </li> <li> min? Nombre d'éléments minimum. </li> <li> max? Nombre d'éléments maximum. </li> <li> tuple? Un tableau dont les éléments sont des noeuds de critères. Représente les éléments fixes que le tableau doit satisfaire. </li> <li> items? Noeud de critères que les éléments du tableau doivent satisfaire. Les éléments définies dans le tableau tuple ne sont pas affectées. </li> </ul> #### **Exemples :** **Validé n'importe quel tableau** ```ts const schema = new Schema({ type: "array" }); ✅ schema.validate([]); ✅ schema.validate(["x"]); ❌ schema.validate({}); ❌ schema.validate("x"); ``` **Validé un tableau d'éléments fixes** ```ts const schema = new Schema({ type: "array", tuple: [ { type: "string" }, { type: "string" } ] }); ✅ schema.validate(["x", "x"]); ❌ schema.validate([]); ❌ schema.validate(["x"]); ❌ schema.validate(["x", "x", "x"]); ``` **Validé un tableau et un sous-tableau d'éléments fixes** ```ts const schema = new Schema({ type: "array", tuple: [ { type: "string" }, { type: "string" }, [ { type: "number" }, { type: "number" } ] ] }); ✅ schema.validate(["x", "x", [0, 0]]); ❌ schema.validate([]); ❌ schema.validate(["x"]); ❌ schema.validate(["x", "x", []]); ❌ schema.validate(["x", "x", [0]]); ``` **Validé un tableau d'éléments fixes et des éléments dynamiques libres** ```ts const schema = new Schema({ type: "array", tuple: [ { type: "string" }, { type: "string" } ], items: { type: "unknown" } }); ✅ schema.validate(["x", "x"]); ✅ schema.validate(["x", "x", 0]); ✅ schema.validate(["x", "x", ""]); ✅ schema.validate(["x", "x", {}]); ❌ schema.validate([]); ❌ schema.validate(["x"]); ❌ schema.validate([0, "x"]); ``` **Validé un tableau d'éléments fixes et des éléments dynamiques contraints** ```ts const schema = new Schema({ type: "array", tuple: [ { type: "string" }, { type: "string" } ], items: { type: "number" } }); ✅ schema.validate(["x"]); ✅ schema.validate(["x", "x"]); ✅ schema.validate(["x", "x", 0]); ✅ schema.validate(["x", "x", 0, 0]); ❌ schema.validate([]); ❌ schema.validate(["x"]); ❌ schema.validate(["x", "x", "x"]); ❌ schema.validate(["x", "x", "x", "x"]); ``` **Validé un tableau avec éléments dynamiques contraints** ```ts const schema = new Schema({ type: "array", items: { type: "string" } }); ✅ schema.validate([]); ✅ schema.validate(["x"]); ✅ schema.validate(["x", "x"]); ❌ schema.validate([0]); ❌ schema.validate(["x", 0]); ❌ schema.validate(["x", "x", 0]); ``` ### Symbol #### **Propriétés :** <ul> <li> type: "symbol" </li> <li> literal? <ul> <li>symbol: Restreint la valeur à un seul symbole valide.</li> <li>array: Restreint la valeur avec un tableau où les items représentent les symboles valides.</li> <li>object: Restreint la valeur avec un objet où les valeurs représentent les symboles valides.</li> </ul> </li> <li> custom(value)? Fonction de validation custom qui reçoit la valeur en paramètre et doit renvoyer un booléen indiquant si la celle-ci est valide. </li> </ul> #### **Exemples :** **Validé n'importe quel symbole** ```ts const xSymbol = Symbol("x"); const ySymbol = Symbol("y"); const schema = new Schema({ type: "symbol" }); ✅ schema.validate(xSymbol); ✅ schema.validate(ySymbol); ``` **Validé un symbole spécifique** ```ts const xSymbol = Symbol("x"); const ySymbol = Symbol("y"); const schema = new Schema({ type: "symbol", literal: xSymbol }); ✅ schema.validate(xSymbol); ❌ schema.validate(ySymbol); ``` **Validé des symboles spécifiques avec un tableau** ```ts const xSymbol = Symbol("x"); const ySymbol = Symbol("y"); const zSymbol = Symbol("z"); const schema = new Schema({ type: "symbol", literal: [xSymbol, ySymbol] }); ✅ schema.validate(xSymbol); ✅ schema.validate(ySymbol); ❌ schema.validate(zSymbol); ``` **Validé des symboles spécifiques avec un enum** ```ts enum mySymbol { X = Symbol("x"), Y = Symbol("y") }; enum otherSymbol { Z = Symbol("z") }; const schema = new Schema({ type: "symbol", literal: mySymbol }); ✅ schema.validate(mySymbol.X); ✅ schema.validate(mySymbol.Y); ❌ schema.validate(otherSymbol.Z); ``` ### Union #### **Propriétés :** <ul> <li> union Un tableau de noeuds de critères, où chaque noeud définit une valeur acceptable. Une valeur est considérée comme valide si elle correspond à au moins un des noeuds de critères fournis. </li> </ul> #### **Exemples :** ```ts const schema = new Schema({ type: "union", union: [ { type: "string" }, { type: "number" } ] }); ✅ schema.validate(0); ✅ schema.validate(""); ❌ schema.validate({}); ``` ### Null #### **Propriétés :** <ul> <li> type: "null" </li> </ul> #### **Exemples :** ```ts const schema = new Schema({ type: "null" }); ✅ schema.validate(null); ❌ schema.validate(0); ❌ schema.validate(""); ❌ schema.validate({}); ``` ### Undefined #### **Propriétés :** <ul> <li> type: "undefined" </li> </ul> #### **Exemples :** ```ts const schema = new Schema({ type: "undefined" }); ✅ schema.validate(undefined); ❌ schema.validate(0); ❌ schema.validate(""); ❌ schema.validate({}); ``` ## Exemples ### Schéma simple ```ts const user = new Schema({ type: "object", shape: { name: { type: "string", min: 3, max: 32 }, role: { type: "string", literal: ["WORKER", "CUSTOMER"] } } }); ✅ user.validate({ name: "Alice", role: "WORKER" }); ❌ user.validate({ name: "Alice", role: "MANAGER" }); ``` ### Schéma composite ```ts const name = new Schema({ type: "string", min: 3, max: 32 }); const role = new Schema({ type: "string", literal: ["WORKER", "CUSTOMER"] }); const user = new Schema({ type: "object", shape: { name: name.criteria, role: role.criteria } }); ✅ user.validate({ name: "Bob", role: "CUSTOMER" }); ❌ user.validate({ name: "Bob", role: "MANAGER" }); ``` ### Schéma composite profond ```ts const name = new Schema({ type: "string", min: 3, max: 32 }); const setting = new Schema({ type: "object", shape: { theme: { type: "string", literal: ["DARK", "LIGHT"] }, notification: { type: "boolean" } } }); const user = new Schema({ type: "object", object: { name: name.criteria, theme: setting.criteria.shape.theme } }); ✅ user.validate({ name: "Alice", theme: "DARK" }); ❌ user.validate({ name: "Alice", theme: "DEFAULT" }); ``` # Testers ## Object #### `isObject(value): boolean` Vérifie si la valeur fournie est de type **object**. #### `isPlainObject(value): boolean` Vérifie si la valeur fournie est de type **object** et dont le prototype est soit **Object.prototype**, soit **null**. Par exemple les valeurs créées via le littérale **{}** ou via **Object.create(null)** font partie des valeurs acceptées. #### `isArray(value): boolean` Vérifie si la valeur fournie est de type **array**. #### `isTypedArray(value): boolean` Vérifie si la valeur fournie est de type **array** et si elle est une vue sur un **ArrayBuffer**, à l’exception des **DataView**. #### `isFunction(value): boolean` Vérifie si la valeur fournie est de type **function**. #### `isBasicFunction(value): boolean` Vérifie si la valeur fournie est de type **function** et qu'elle n'est pas de nature **async**, **generator** ou **async generator**. #### `isAsyncFunction(value): boolean` Vérifie si la valeur fournie est de type **function** et qu'elle n'est pas de nature **basic**, **generator** ou **async generator**. #### `isGeneratorFunction(value): boolean` Vérifie si la valeur fournie est de type **function** et qu'elle n'est pas de nature **basic**, **async** ou **async generator**. #### `isAsyncGeneratorFunction(value): boolean` Vérifie si la valeur fournie est de type **function** et qu'elle n'est pas de nature **basic**, **async** ou **generator**. ## String #### `isAscii(str): boolean` Vérifie si la chaîne fournie n'est composée que de caractères ASCII.  #### `isIpV4(str [, options]): boolean` Vérifie si la chaîne fournie correspond à une IPV4. #### `isIpV6(str [, options]): boolean` Vérifie si la chaîne fournie correspond à une IPV6. #### `isIp(str [, options]): boolean` Vérifie si la chaîne fournie correspond à une IPV4 ou une IPV6. **Options:** <ul> <li> cidr? — (Default: false) Si true, rend obligatoire la présence d'un suffixe CIDR, sinon si false un suffixe n'est pas accepté. </li> </ul> #### `isEmail(str [, options]): boolean` Vérifie si la chaîne fournie correspond à une adresse email. **Options:** <ul> <li> allowLocalQuotes?: boolean — (Default: false) Spécifie si la première partie (partie locale) de l'adresse email peut être formée à l'aide de guillemets. Par exemple, "Jean Dupont"@exemple.com sera considéré comme valide. </li> <li> allowIpAddress?: boolean — (Default: false) Spécifie si la deuxième partie (partie domain) de l'adresse email peut être une adresse IP. Par exemple, foo@8.8.8.8 sera considéré comme valide. </li> <li> allowGeneralAddress?: boolean — (Default: false) Spécifie si la deuxième partie (partie domain) de l'adresse email peut être une adresse general. Par exemple, foo@8.8.8.8 sera considéré comme valide. </li> </ul> **Standards:** RFC 5321 #### `isDomain(str): boolean` Vérifie si la chaîne fournie correspond un nom de domain. **Standards:** RFC 1035 #### `isDataURL(str [, options]): boolean` Vérifie si la chaîne fournie correspond à une **DataURL**. **Options:** <ul> <li> type?: string[] Spécifie un ou plusieurs types MIME autorisés. <a href="http://www.iana.org/assignments/media-types/">Liste des types MIME enregistrés par l'IANA ↗</a> </li> <li> subtype?: string[] Spécifie un ou plusieurs sous-types MIME autorisés. <a href="http://www.iana.org/assignments/media-types/">Liste des types MIME enregistrés par l'IANA ↗</a> </li> </ul> **Standards:** RFC 2397 #### `isUuid(str [, options]): boolean` Vérifie si la chaîne fournie correspond à un **UUID** valide. **Options:** <ul> <li> version?: number Spécifie le numéro de version autorisé, compris entre 1 et 7. </li> </ul> **Standards:** RFC 9562 #### `isBase16(str): boolean` Vérifie si la chaîne fournie correspond à un encodage **base16** valide. **Standards:** RFC 4648 #### `isBase32(str): boolean` Vérifie si la chaîne fournie correspond à un encodage **base32** valide. **Standards:** RFC 4648 #### `isBase32Hex(str): boolean` Vérifie si la chaîne fournie correspond à un encodage **base32Hex** valide. **Standards:** RFC 4648 #### `isBase64(str): boolean` Vérifie si la chaîne fournie correspond à un encodage **base64** valide. **Standards:** RFC 4648 #### `isBase64Url(str): boolean` Vérifie si la chaîne fournie correspond à un encodage **base64Url** valide. **Standards:** RFC 4648 # Helpers ## Object #### `getInternalTag(target): string` Retourne le tag interne de la cible. Par exemple pour une cible **async () => {}** le tag retourné est **"AsyncFunction"**. ## String #### `base16ToBase32(str [, to, padding]): string` Convertie une chaîne en **base16** en une chaîne en **base32** ou **base32Hex**. **Arguments:** <ul> <li> to?: "B32" | "B32HEX" — (Default: "B32") Spécifie dans quel encodage la chaîne doit être convertie. </li> <li> padding?: boolean — (Default: true) Spécifie si la chaîne doit être complétée par un remplissage si nécessaire. </li> </ul> **Standards:** RFC 4648 #### `base16ToBase64(str [, to, padding]): string` Convertie une chaîne en **base16** en une chaîne en **base64** ou **base64Url**. **Arguments:** <ul> <li> to?: "B64" | "B64URL" — (Default: "B64") Spécifie dans quel encodage la chaîne doit être convertie. </li> <li> padding?: boolean — (Default: true) Spécifie si la chaîne doit être complétée par un remplissage si nécessaire. </li> </ul> **Standards:** RFC 4648 #### `base32ToBase16(str [, from]): string` Convertie une chaîne en **base32** ou **base32Hex** en une chaîne en **base16**. **Arguments:** <ul> <li> from?: "B32" | "B32HEX" — (Default: "B32") Spécifie dans quel encodage la chaîne doit être fournie. </li> </ul> **Standards:** RFC 4648 #### `base64ToBase16(str [, from]): string` Convertie une chaîne en **base64** ou **base64Url** en une chaîne en **base16**. **Arguments:** <ul> <li> from?: "B64" | "B64URL" — (Default: "B64") Spécifie dans quel encodage la chaîne doit être fournie. </li> </ul>