@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.6

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">;

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

@@ -0,0 +1,31 @@
+/**
+ * @title DString.isUuid
+ *
+ * Vérifier qu'une chaîne respecte le format UUID pris en charge.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const value: string;
+
+if (DString.isUuid(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, string & DString.Uuid, "strict">;
+}
+
+const result = DString.isUuid("550e8400-e29b-41d4-a716-446655440000");
+// 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’UUID validé.
+const normalized = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.isUuid,
+		(uuid) => {
+			type _CheckUuid = DCommon.ExpectType<typeof uuid, string & DString.Uuid, "strict">;
+
+			return DString.toLowerCase(uuid);
+		},
+	),
+);
+type _CheckNormalized = DCommon.ExpectType<typeof normalized, string, "strict">;

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

@@ -0,0 +1,18 @@
+/**
+ * @title DString.join
+ *
+ * Réunir les chaînes d'une collection avec un séparateur.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+declare const values: readonly ["duplo", "js"];
+const result = DString.join(values, "-");
+// La valeur obtenue est "duplo-js".
+type _CheckResult = DCommon.ExpectType<typeof result, "duplo-js", "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DString.join("-"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "duplo-js", "strict">;

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.lastIndexOf
+ *
+ * Retourner la dernière 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.lastIndexOf("one-two-two", "two");
+// La valeur obtenue est 8.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"one-two-two",
+	DString.lastIndexOf("two"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

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

@@ -0,0 +1,18 @@
+/**
+ * @title DString.length
+ *
+ * Retourner le nombre de caractères d'une 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.length("DuploJS");
+// La valeur obtenue est 7 et elle est toujours strictement positive.
+type _CheckResult = DCommon.ExpectType<typeof result, number & DNumber.Positive, "strict">;
+
+const piped = DCommon.pipe(
+	"DuploJS",
+	DString.length,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number & DNumber.Positive, "strict">;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DString.lengthEqual
+ *
+ * Tester ou établir qu'une chaîne possède exactement un nombre donné de caractères.
+ */
+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.lengthEqual("Duplo", 5);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.lengthEqual(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.LengthEqual<5>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.lengthEqual(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.LengthEqual<5>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur exacte établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DString.maxCharacters
+ *
+ * Tester ou établir une longueur maximale pour une 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.maxCharacters("Duplo", 10);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.maxCharacters(value, 10)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.MaxCharacters<10>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.maxCharacters(10),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.MaxCharacters<10>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur maximale établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DString.minCharacters
+ *
+ * Tester ou établir une longueur minimale pour une 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.minCharacters("DuploJS", 3);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.minCharacters(value, 3)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, string & DString.MinCharacters<3>, "strict">;
+	const length = DString.length(value);
+	type _CheckLength = DCommon.ExpectType<typeof length, number & DNumber.Positive, "strict">;
+}
+
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DString.minCharacters(3),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, string & DString.MinCharacters<3>, "strict">;
+			return DString.length(value);
+		},
+	),
+);
+// La branche vraie peut exploiter la longueur minimale établie par le predicate.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, string | (number & DNumber.Positive), "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.normalize
+ *
+ * Normaliser une chaîne selon une forme Unicode.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.normalize("e\u0301", "NFC");
+// La valeur obtenue est la représentation NFC de la chaîne.
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"e\u0301",
+	DString.normalize("NFC"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.padEnd
+ *
+ * Compléter une chaîne par la droite jusqu'à une longueur cible.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.padEnd("42", 5, "0");
+// La valeur obtenue est "42000".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MinCharacters<2>, "strict">;
+
+const piped = DCommon.pipe(
+	"42",
+	DString.padEnd(5, "0"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MinCharacters<2>, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.padStart
+ *
+ * Compléter une chaîne par la gauche jusqu'à une longueur cible.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.padStart("42", 5, "0");
+// La valeur obtenue est "00042".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MinCharacters<2>, "strict">;
+
+const piped = DCommon.pipe(
+	"42",
+	DString.padStart(5, "0"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MinCharacters<2>, "strict">;

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.prepend
+ *
+ * Ajouter une ou plusieurs chaînes au début d'une chaîne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.prepend("hello", "say ");
+// La valeur obtenue est "say hello".
+type _CheckResult = DCommon.ExpectType<typeof result, "say hello", "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.prepend("say "),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, "say hello", "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.repeat
+ *
+ * Répéter une chaîne un nombre positif de fois.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.repeat("ha", 3);
+// La valeur obtenue est "hahaha".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"ha",
+	DString.repeat(3),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

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

@@ -0,0 +1,18 @@
+/**
+ * @title DString.replace
+ *
+ * Remplacer la première occurrence d'un motif par une chaîne ou une fonction de remplacement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.replace("hello world", "world", "DuploJS");
+// La valeur obtenue est "hello DuploJS".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.replace("world", ({ matchedValue }) => DString.toUpperCase(matchedValue)),
+);
+// Le replacer reçoit les informations structurées sur la correspondance.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.replaceAll
+ *
+ * Remplacer toutes les occurrences d'un motif par une chaîne ou une fonction de remplacement.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.replaceAll("a-b-c", "-", "/");
+// La valeur obtenue est "a/b/c".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+const piped = DCommon.pipe(
+	"a-b-c",
+	DString.replaceAll("-", "/"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.search
+ *
+ * Retourner la position d'un motif, ou `undefined` lorsqu'il ne correspond pas.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.search("hello42", /\d+/);
+// La valeur obtenue est 5.
+type _CheckResult = DCommon.ExpectType<typeof result, number | undefined, "strict">;
+
+const piped = DCommon.pipe(
+	"hello42",
+	DString.search(/\d+/),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | undefined, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.shift
+ *
+ * Retirer 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.shift("hello");
+// La valeur obtenue est "ello".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<5>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello",
+	DString.shift,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<5>, "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.slice
+ *
+ * Extraire une portion d'une chaîne entre deux index.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.slice("hello world", 0, 5);
+// La valeur obtenue est "hello".
+type _CheckResult = DCommon.ExpectType<typeof result, string & DString.MaxCharacters<11>, "strict">;
+
+const piped = DCommon.pipe(
+	"hello world",
+	DString.slice(0, 5),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string & DString.MaxCharacters<11>, "strict">;

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

@@ -0,0 +1,19 @@
+/**
+ * @title DString.sort
+ *
+ * Trier une copie d'une collection de chaînes dans l'ordre croissant ou décroissant.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const values: readonly string[] = ["b", "a", "c"];
+const result = DString.sort(values, "ASC");
+// La valeur obtenue est une nouvelle collection triée ["a", "b", "c"].
+type _CheckResult = DCommon.ExpectType<typeof result, string[], "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DString.sort("DSC"),
+);
+// Le pipe retourne une copie triée dans l'ordre décroissant.
+type _CheckPiped = DCommon.ExpectType<typeof piped, string[], "strict">;

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

@@ -0,0 +1,17 @@
+/**
+ * @title DString.sortCompare
+ *
+ * Comparer deux chaînes avec l'ordre de tri du domaine String.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.sortCompare("file2", "file10");
+// La valeur obtenue est un nombre négatif car "file2" précède "file10".
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	"file2",
+	DString.sortCompare("file10"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

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

@@ -0,0 +1,34 @@
+/**
+ * @title DString.split
+ *
+ * Découper une chaîne selon un séparateur, avec une limite facultative.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DString.split("a,b,c", ",");
+// La valeur obtenue contient exactement trois éléments : ["a", "b", "c"].
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	readonly string[] & DArray.MinElements<3> & DArray.LengthEqual<3> & DArray.MaxElements<3>,
+	"strict"
+>;
+
+const piped = DCommon.pipe(
+	"a,b,c",
+	DString.split(","),
+);
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly string[] & DArray.MinElements<3> & DArray.LengthEqual<3> & DArray.MaxElements<3>,
+	"strict"
+>;
+
+const limited = DString.split("a,b,c", ",", { limit: 2 });
+// La limite réduit la sortie aux deux premiers groupes : ["a", "b"].
+type _CheckLimited = DCommon.ExpectType<
+	typeof limited,
+	readonly string[] & DArray.MinElements<2> & DArray.LengthEqual<2> & DArray.MaxElements<2>,
+	"strict"
+>;

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

@@ -0,0 +1,33 @@
+/**
+ * @title DString.startsWith
+ *
+ * Tester si une chaîne commence 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.startsWith("user-api", "user");
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: string;
+
+if (DString.startsWith(value, "user")) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, `user${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.startsWith("user"),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, `user${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">;