@duplojs/agents-kit 0.1.0-beta.3 → 0.1.0-beta.7

package/docs/API/10-lang/10-printer/10-primitives.md

@@ -0,0 +1,19 @@
+### Constantes et types de DPrinter
+
+Les enums publiques sélectionnent les fins de ligne et les unités d'indentation, tandis que les types décrivent les paramètres et les valeurs acceptées par les fonctions de rendu.
+
+---
+
+`Indent` est une enum créée avec `DCommon.createEnum`, qui propose `tab`, `space1`, `space2`, `space3` et `space4`. `Back` propose `LF` et `CRLF`. Les types du même nom représentent leurs valeurs respectives. Ces enums ne produisent pas de texte : leur interprétation appartient aux fonctions de rendu.
+
+`RenderLineParams` expose un `joinCharacter` optionnel, égal à une espace par défaut. `RenderParagraphParams` expose un `back` optionnel, égal à `Back.LF` par défaut ; le séparateur du paragraphe est exclusivement cette fin de ligne.
+
+Les deux fonctions acceptent un `indent` optionnel, sélectionné avec `Indent`, et un `indentLevel` optionnel, égal à `0` par défaut. Sans type ou sans quantité, aucune indentation n'est ajoutée. La quantité multiplie l'unité choisie : `Indent.space2` avec `indentLevel: 3` produit six espaces. Les quantités négatives ou non finies désactivent l'indentation ; les fractions positives sont tronquées.
+
+`renderLine` préfixe uniquement le début du texte assemblé. `renderParagraph` préfixe chaque ligne, y compris celles déjà présentes dans les chaînes d'entrée, en préservant leurs fins de ligne. Un tableau sans valeur rendable produit toujours une chaîne vide.
+
+La constante `dash` vaut `"-"`.
+
+`Colors` est l’union des couleurs ANSI disponibles : `"red"`, `"green"`, `"yellow"`, `"blue"`, `"magenta"`, `"cyan"` et `"gray"`. Les fonctions `colorized` et `colorizedBold` utilisent cette union pour sélectionner leur couleur.
+
+`RenderInput` décrit les valeurs acceptées par les fonctions de rendu : `string | boolean | null | undefined | readonly RenderInput[]`. Les tableaux peuvent contenir récursivement d’autres tableaux. À l’exécution, les tableaux imbriqués sont parcourus, `true` est rendu sous la forme `"true"`, tandis que `false`, `null` et `undefined` sont ignorés.

package/docs/API/10-lang/10-printer/10-renderLine.ts

@@ -0,0 +1,36 @@
+/**
+ * @title DPrinter.renderLine
+ *
+ * Assembler récursivement des valeurs en séparant les éléments par une espace.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import type * as DCommon from "@duplojs/lang/common";
+
+const line = DPrinter.renderLine(["Nom", [true, "Ada"], false]);
+
+// La valeur obtenue est "Nom true Ada" ; false ne produit aucun texte.
+type _CheckLine = DCommon.ExpectType<typeof line, string, "strict">;
+
+const indentedLine = DPrinter.renderLine(["Nom", "Ada"], {
+	indent: DPrinter.Indent.space2,
+	indentLevel: 1,
+});
+// La valeur obtenue est "  Nom Ada" : l'indentation préfixe la ligne une seule fois.
+type _CheckIndentedLine = DCommon.ExpectType<typeof indentedLine, string, "strict">;
+
+// Un séparateur personnalisé permet notamment d'assembler des fragments sans espace.
+const compact = DPrinter.renderLine(["Nom", ": ", "Ada"], {
+	joinCharacter: "",
+	indent: DPrinter.Indent.tab,
+	indentLevel: 2,
+});
+// La valeur obtenue est "\t\tNom: Ada".
+type _CheckCompact = DCommon.ExpectType<typeof compact, string, "strict">;
+
+// Une chaîne multiligne conserve ses lignes suivantes sans indentation ajoutée.
+const multiline = DPrinter.renderLine(["Nom\nAda"], {
+	indent: DPrinter.Indent.space2,
+	indentLevel: 1,
+});
+// La valeur obtenue est "  Nom\nAda".
+type _CheckMultiline = DCommon.ExpectType<typeof multiline, string, "strict">;

package/docs/API/10-lang/10-printer/10-renderParagraph.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DPrinter.renderParagraph
+ *
+ * Assembler récursivement des valeurs en séparant les éléments par un saut de ligne.
+ */
+import * as DPrinter from "@duplojs/lang/printer";
+import * as DCommon from "@duplojs/lang/common";
+
+const paragraph = DPrinter.renderParagraph([
+	"Première ligne",
+	["Deuxième ligne", false],
+	"Troisième ligne",
+]);
+
+// La valeur obtenue est "Première ligne\nDeuxième ligne\nTroisième ligne".
+type _CheckParagraph = DCommon.ExpectType<typeof paragraph, string, "strict">;
+
+// Le rendu direct permet de choisir CRLF et une indentation par ligne.
+const windowsParagraph = DPrinter.renderParagraph(["Première", "Deuxième"], {
+	back: DPrinter.Back.CRLF,
+	indent: DPrinter.Indent.tab,
+	indentLevel: 1,
+});
+// La valeur obtenue est "\tPremière\r\n\tDeuxième".
+type _CheckWindowsParagraph = DCommon.ExpectType<typeof windowsParagraph, string, "strict">;
+
+// La forme curifiée configure le rendu avant de recevoir les valeurs du pipe.
+const spacedParagraph = DCommon.pipe(
+	["Première", ["Deuxième", false]],
+	DPrinter.renderParagraph({
+		back: DPrinter.Back.LF,
+		indent: DPrinter.Indent.space2,
+		indentLevel: 1,
+	}),
+);
+// La valeur obtenue est "  Première\n  Deuxième".
+type _CheckSpacedParagraph = DCommon.ExpectType<typeof spacedParagraph, string, "strict">;

package/docs/API/10-lang/10-printer/index.llms.md

@@ -0,0 +1,29 @@
+## DPrinter
+
+Fonctions et constantes pour assembler du texte, formater des lignes et paragraphes, ajouter une indentation ou des styles ANSI.
+
+### [Constantes et types de DPrinter](10-primitives.md)
+
+Les enums publiques sélectionnent les fins de ligne et les unités d'indentation, tandis que les types décrivent les paramètres et les valeurs acceptées par les fonctions de rendu.
+
+
+### [DPrinter.bold](10-bold.ts)
+
+Encadrer une chaîne par les codes ANSI de mise en gras.
+ 
+### [DPrinter.colorized](10-colorized.ts)
+
+Encadrer une chaîne par les codes ANSI d’une couleur sélectionnée.
+ 
+### [DPrinter.colorizedBold](10-colorizedBold.ts)
+
+Appliquer une couleur ANSI et le style gras à une chaîne.
+ 
+### [DPrinter.renderLine](10-renderLine.ts)
+
+Assembler récursivement des valeurs en séparant les éléments par une espace.
+ 
+### [DPrinter.renderParagraph](10-renderParagraph.ts)
+
+Assembler récursivement des valeurs en séparant les éléments par un saut de ligne.
+ 

package/docs/API/10-lang/10-printer/index.md

@@ -0,0 +1,3 @@
+## DPrinter
+
+Fonctions et constantes pour assembler du texte, formater des lignes et paragraphes, ajouter une indentation ou des styles ANSI.

package/docs/API/10-lang/10-string/10-at.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.at
+ *
+ * Lire le caractère situé à un index, avec `undefined` lorsque l'index est hors limites.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.at("hello", 1);
+// La valeur obtenue est "e".
+type _CheckResult = DCommon.ExpectType<typeof result, "e", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.at(1),
+);
+// La forme curifiée s'intègre dans un pipe et conserve le caractère "e".
+type _CheckPiped = DCommon.ExpectType<typeof piped, "e", "strict">;

package/docs/API/10-lang/10-string/10-capitalize.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.capitalize
+ *
+ * Mettre en majuscule le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.capitalize("duplo");
+// La valeur obtenue est "Duplo".
+type _CheckResult = DCommon.ExpectType<typeof result, "Duplo", "strict">;
+
+const piped = DCommon.pipe(
+	"duplo",
+	DString.capitalize,
+);
+// La fonction unaire peut être passée directement au pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "Duplo", "strict">;

package/docs/API/10-lang/10-string/10-charAt.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.charAt
+ *
+ * Lire le caractère situé à un index positif ou nul.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.charAt("hello", 1);
+// La valeur obtenue est une chaîne d'au plus un caractère, ici "e".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<1>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.charAt(1),
+);
+// La forme curifiée conserve la garantie de longueur maximale.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<1>, "strict">;

package/docs/API/10-lang/10-string/10-concat.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.concat
+ *
+ * Ajouter une ou plusieurs chaînes à la fin d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.concat("hello", " ", "world");
+// La valeur obtenue est "hello world".
+type _CheckResult = DCommon.ExpectType<typeof result, "hello world", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.concat(" "),
+);
+// La forme curifiée fixe l'élément ajouté dans l'étape du pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, "hello ", "strict">;

package/docs/API/10-lang/10-string/10-endsWith.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.endsWith
+ *
+ * Tester si une chaîne se termine par une sous-chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.endsWith("user-api", "api");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.endsWith(value, "api")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `${string}api`, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.endsWith("api"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `${string}api`, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-extract.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.extract
+ *
+ * Extraire la première occurrence d'un motif avec ses groupes et sa position.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.extract("order-42", /(?<kind>order)-(?<id>\d+)/);
+// Le résultat contient la correspondance, les groupes, les groupes nommés, la position et la chaîne source.
+type _CheckResult = DCommon.ExpectType<typeof result, DString.ExtractOutput<"order-42"> | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42",
+	DString.extract(/\d+/),
+);
+// La forme curifiée recherche le même motif sur la chaîne reçue par le pipe.
+type _CheckPiped = DCommon.ExpectType<typeof piped, DString.ExtractOutput<"order-42"> | undefined, "strict">;

package/docs/API/10-lang/10-string/10-extractAll.ts

@@ -0,0 +1,18 @@
+/**
+ * @title DString.extractAll
+ *
+ * Produire les occurrences d'un motif global sous forme de génératrice.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.extractAll("order-42/order-43", /order-\d+/g);
+// La génératrice produit un objet d'extraction pour chaque occurrence.
+type _CheckResult = DCommon.ExpectType<typeof result, Generator<DString.ExtractOutput<"order-42/order-43">>, "strict">;
+
+const piped = DCommon.pipe(
+	"order-42/order-43",
+	DString.extractAll(/order-\d+/g),
+);
+// La forme curifiée conserve le type de la chaîne d'origine dans chaque extraction.
+type _CheckPiped = DCommon.ExpectType<typeof piped, Generator<DString.ExtractOutput<"order-42/order-43">>, "strict">;

package/docs/API/10-lang/10-string/10-first.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.first
+ *
+ * Lire le premier caractère d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.first("hello");
+// La valeur obtenue est "h".
+type _CheckResult = DCommon.ExpectType<typeof result, "h", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.first,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "h", "strict">;

package/docs/API/10-lang/10-string/10-includes.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.includes
+ *
+ * Tester si une chaîne contient une sous-chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.includes("hello world", "world");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.includes(value, "world")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `${string}world${string}`, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.includes("world"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `${string}world${string}`, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-indexOf.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DString.indexOf
+ *
+ * Retourner la position d'une sous-chaîne, ou `undefined` si elle est absente.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.indexOf("hello world", "world");
+// La valeur obtenue est 6.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.indexOf("world"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

package/docs/API/10-lang/10-string/10-isComposedOf.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.isComposedOf
+ *
+ * Vérifier qu'une chaîne ne contient que des caractères appartenant à une ou plusieurs plages.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.isComposedOf("abc123", ["a-z", "0-9"]);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.isComposedOf(value, "a-z")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.AllowedCharacters<"a-z">, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isComposedOf("a-z"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.AllowedCharacters<"a-z">, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la chaîne affinée pour calculer sa longueur.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isEmail.ts

@@ -0,0 +1,56 @@
+/**
+ * @title DString.isEmail
+ *
+ * Vérifier qu'une chaîne respecte le format d'une adresse e-mail.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isEmail(value)) {
+	// Le test établit la contrainte Email dans cette branche.
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Email, "strict">;
+}
+
+const result = DString.isEmail("contact@duplojs.dev");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// `Email` est établi dans la branche, mais `split` ne peut pas déduire le séparateur
+// depuis cette contrainte : pour une entrée typée `string`, il garantit au moins un fragment.
+const emailParts = DString.split(value, "@");
+type _CheckEmailParts = DCommon.ExpectType<
+	typeof emailParts,
+	readonly string[] & DArray.MinElements<1>,
+	"strict"
+>;
+
+if (DString.isEmail(value)) {
+	type _CheckEmail = DCommon.ExpectType<typeof value, string & DString.Email, "strict">;
+	const parts = DString.split(value, "@");
+	type _CheckParts = DCommon.ExpectType<
+		typeof parts,
+		readonly string[] & DArray.MinElements<2>,
+		"strict"
+	>;
+}
+
+// Le même contrôle s’insère dans un pipe ; la longueur des fragments reste garantie.
+const partCount = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isEmail,
+		(email) => {
+			type _CheckEmail = DCommon.ExpectType<typeof email, string & DString.Email, "strict">;
+
+			return DString.split(email, "@");
+		},
+	),
+);
+type _CheckPartCount = DCommon.ExpectType<
+	typeof partCount,
+	string | (readonly string[] & DArray.MinElements<2>),
+	"strict"
+>;

package/docs/API/10-lang/10-string/10-isIn.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DString.isIn
+ *
+ * Vérifier qu'une chaîne appartient à une collection de valeurs autorisées.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+declare const values: readonly ["draft", "published"];
+const result = DString.isIn("draft", values);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.isIn(value, values)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, "draft" | "published", "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isIn(values),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, "draft" | "published", "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la valeur réduite à l'union autorisée.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isKeyof.ts

@@ -0,0 +1,37 @@
+/**
+ * @title DString.isKeyof
+ *
+ * Vérifier qu'une valeur est une clé de l'objet fourni et affiner son type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const source = {
+	name: "Alice",
+	email: "alice@example.com",
+};
+const result = DString.isKeyof("name", source);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const key: string;
+
+if (DString.isKeyof(key, source)) {
+	type _CheckIfKey = DCommon.ExpectType<typeof key, "name" | "email", "strict">;
+	const length = DString.length(key);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	key,
+	DCommon.when(
+		DString.isKeyof(source),
+		(key) => {
+			type _CheckKey = DCommon.ExpectType<typeof key, "name" | "email", "strict">;
+			return DString.length(key);
+		},
+	),
+);
+// La branche vraie peut exploiter la clé réduite aux propriétés de l'objet.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isNotEmpty.ts

@@ -0,0 +1,32 @@
+/**
+ * @title DString.isNotEmpty
+ *
+ * Vérifier qu'une chaîne contient au moins un caractère.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isNotEmpty(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.NotEmpty, "strict">;
+}
+
+const result = DString.isNotEmpty("DuploJS");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le predicate unaire s’utilise aussi dans un pipe pour mesurer la chaîne validée.
+const length = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isNotEmpty,
+		(nonEmpty) => {
+			type _CheckValue = DCommon.ExpectType<typeof nonEmpty, string & DString.NotEmpty, "strict">;
+
+			return DString.length(nonEmpty);
+		},
+	),
+);
+type _CheckLength = DCommon.ExpectType<typeof length, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isNumber.ts

@@ -0,0 +1,32 @@
+/**
+ * @title DString.isNumber
+ *
+ * Vérifier qu'une chaîne représente un nombre et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isNumber(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Number, "strict">;
+}
+
+const result = DString.isNumber("42.5");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le predicate unaire peut aussi s’utiliser directement dans DCommon.when.
+const normalized = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isNumber,
+		(numberString) => {
+			type _CheckNumberString = DCommon.ExpectType<typeof numberString, string & DString.Number, "strict">;
+
+			return DString.length(numberString);
+		},
+	),
+);
+type _CheckNormalized = DCommon.ExpectType<typeof normalized, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isTrimmed.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DString.isTrimmed
+ *
+ * Vérifier qu'une chaîne ne possède pas d'espace superflu à ses extrémités.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isTrimmed(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Trimmed, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const result = DString.isTrimmed("DuploJS");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+const length = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isTrimmed,
+		(trimmed) => {
+			type _CheckTrimmed = DCommon.ExpectType<typeof trimmed, string & DString.Trimmed, "strict">;
+
+			return DString.length(trimmed);
+		},
+	),
+);
+type _CheckLength = DCommon.ExpectType<typeof length, string | (number & DNumber.Positive), "strict">;

package/docs/API/10-lang/10-string/10-isUrl.ts

@@ -0,0 +1,31 @@
+/**
+ * @title DString.isUrl
+ *
+ * Vérifier qu'une chaîne est une URL valide.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isUrl(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Url, "strict">;
+}
+
+const result = DString.isUrl("https://duplojs.dev");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le predicate unaire s’utilise aussi dans un pipe pour normaliser l’URL validée.
+const normalized = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isUrl,
+		(url) => {
+			type _CheckUrl = DCommon.ExpectType<typeof url, string & DString.Url, "strict">;
+
+			return DString.toLowerCase(url);
+		},
+	),
+);
+type _CheckNormalized = DCommon.ExpectType<typeof normalized, string, "strict">;