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

package/docs/API.llms.md

@@ -0,0 +1,135 @@
+# Référence API
+
+Références des fonctions publiques de l’écosystème DuploJS, organisées par package, namespace et domaine.
+
+# @duplojs/lang
+
+Primitives fonctionnelles indépendantes de la plateforme pour composer des transformations, manipuler les données et préserver leurs garanties de typage.
+
+## [DArray](API/10-lang/10-array/index.llms.md)
+
+Opérations immuables de lecture, transformation, sélection, réduction et modification de tableaux, avec prise en compte de leurs contraintes de typage.
+
+## [DChrono](API/10-lang/10-chrono/index.llms.md)
+
+Création, calcul, comparaison, sérialisation et formatage des dates, heures, durées et fuseaux horaires dans les représentations Chrono de DuploJS.
+
+## [DCommon](API/10-lang/10-common/index.llms.md)
+
+Fonctions générales de composition, de transformation, de contrôle de flux et de manipulation des valeurs partagées par les autres domaines DuploJS.
+
+## [DDataStructure](API/10-lang/10-dataStructure/index.llms.md)
+
+Construction de contrats de données validables au runtime, composables et reflétés dans les types TypeScript.
+
+## [DEither](API/10-lang/10-either/index.llms.md)
+
+Création, discrimination, transformation et propagation des réussites ou des échecs représentés par `Either`.
+
+## [DGenerator](API/10-lang/10-generator/index.llms.md)
+
+Création et composition de génératrices synchrones ou asynchrones pour produire, transformer, filtrer, réduire et consommer des séquences de valeurs.
+
+## [DNumber](API/10-lang/10-number/index.llms.md)
+
+Prédicats et transformations fonctionnelles pour comparer, vérifier, agréger et trier des nombres tout en conservant leurs contraintes de typage.
+
+## [DObject](API/10-lang/10-object/index.llms.md)
+
+Fonctions fonctionnelles pour lire, discriminer, transformer, fusionner et reconstruire des objets en conservant les informations de typage utiles.
+
+## [DPath](API/10-lang/10-path/index.llms.md)
+
+Chemins Unix typés : déclarer des littéraux, valider et normaliser des chaînes runtime, extraire des segments, résoudre des chemins ou sélectionner des motifs glob, indépendamment du système de fichiers.
+
+## [DPattern](API/10-lang/10-pattern/index.llms.md)
+
+Sélectionner et traiter les variantes d’une union par identité, valeur littérale, motif structurel ou predicate, avec couverture exhaustive ou branche de repli.
+
+## [DPrinter](API/10-lang/10-printer/index.llms.md)
+
+Fonctions et constantes pour assembler du texte, formater des lignes et paragraphes, ajouter une indentation ou des styles ANSI.
+
+## [DString](API/10-lang/10-string/index.llms.md)
+
+Fonctions de manipulation, recherche, validation et transformation des chaînes de caractères, avec des formes curifiées et des contraintes de typage lorsque l'API peut les établir.
+
+## [DTuple](API/10-lang/10-tuple/index.llms.md)
+
+Manipulation et typage des tuples : convertir les garanties de cardinalité en positions typées, puis transformer leurs éléments en conservant leur forme.
+
+# @duplojs/server
+
+Capacités portables de fichiers, environnement, validation de ressources et commandes CLI.
+
+## [File](API/20-server/10-file/index.llms.md)
+
+Lire et modifier les ressources du système de fichiers, leurs chemins et leurs métadonnées.
+
+## [Common](API/20-server/20-common/index.llms.md)
+
+Accéder à la configuration, aux arguments et aux capacités du processus.
+
+## [DataStructure](API/20-server/30-dataStructure/index.llms.md)
+
+Décoder et valider les interfaces de fichiers et dossiers avec les contraintes serveur.
+
+## [Command](API/20-server/40-command/index.llms.md)
+
+Déclarer et exécuter des commandes CLI et leurs entrées typées.
+
+# @duplojs/json-web-token
+
+Politiques JWT réutilisables, signature, chiffrement facultatif et primitives cryptographiques.
+
+## [TokenHandler](API/40-json-web-token/10-tokenHandler/index.llms.md)
+
+Définir une politique et créer, décoder ou vérifier les tokens associés.
+
+## [Signer](API/40-json-web-token/20-signer/index.llms.md)
+
+Configurer la signature et la vérification cryptographiques.
+
+## [Cipher](API/40-json-web-token/30-cipher/index.llms.md)
+
+Configurer le chiffrement et le déchiffrement facultatifs des tokens.
+
+## [Utilitaires JWT](API/40-json-web-token/40-utils/index.llms.md)
+
+Manipuler les encodages et les primitives cryptographiques publiques.
+
+# @duplojs/form
+
+Construction de formulaires typés à partir de champs composables et de leurs validations.
+
+## Form pour Vue
+
+Fabriques de formulaires, de champs et de templates pour l'intégration Vue.
+
+### [Construction de formulaires](API/50-form/10-vue/10-construction/index.llms.md)
+
+Fabriques de formulaires, de champs et de templates.
+
+### [Layouts](API/50-form/10-vue/20-layouts/index.llms.md)
+
+Composition des champs et ajout de structure, validation, contrôle de flux et slots.
+
+### [Design system](API/50-form/10-vue/30-designSystem/index.llms.md)
+
+Composants et inputs prêts à l'emploi pour construire les formulaires et les commandes des templates Grid.
+
+# @duplojs/playwright
+
+Fabriques de site, pages et composants, interactions et assertions pour les parcours E2E.
+
+## [Construction](API/60-playwright/10-construction/index.llms.md)
+
+Fabriques de sites, pages, composants, interactions et wrappers de parcours.
+
+## [Actions](API/60-playwright/20-actions/index.llms.md)
+
+Interactions avec les éléments nommés des pages et composants.
+
+## [Assertions](API/60-playwright/30-assertions/index.llms.md)
+
+Vérifications de l’état des éléments nommés des pages et composants.

package/docs/concepts/01-fundamental/01-constraint/01-use.ts

@@ -0,0 +1,22 @@
+/**
+ * @title Acquisition des contraintes.
+ *
+ * Vérification runtime et narrowing vers un type contraint.
+ */
+import * as DNumber from "@duplojs/lang/number";
+
+// Une contrainte existe uniquement dans le typage : elle ne modifie ni ne valide la valeur.
+// L’intersection compose ici deux garanties établies par les predicates.
+type Age = number & DNumber.Integer & DNumber.Positive;
+
+// @ts-expect-error Le littéral seul ne porte pas les contraintes attendues.
+const age: Age = 12;
+
+// Chaque vérification réussie enrichit le type sans changer la valeur runtime.
+const maybeAge = 12;
+if (
+	DNumber.isInteger(maybeAge)
+	&& DNumber.isPositive(maybeAge)
+) {
+	const age: Age = maybeAge;
+}

package/docs/concepts/01-fundamental/01-constraint/10-built-in-constraint.ts

@@ -0,0 +1,37 @@
+/**
+ * @title Composition des contraintes fournies.
+ *
+ * Réutilisation et composition des contraintes disponibles dans les domaines.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import type * as DNumber from "@duplojs/lang/number";
+import type * as DString from "@duplojs/lang/string";
+
+// Avant de créer une contrainte, vérifier celles du domaine concerné.
+// Une intersection cumule les garanties ; déclarer ce type ne valide aucune donnée.
+// Nom sans espaces aux extrémités, contenant entre 5 et 35 caractères.
+type Name = (
+	& string
+	& DString.MaxCharacters<35>
+	& DString.MinCharacters<5>
+	& DString.Trimmed
+);
+
+// Entier strictement positif, supérieur ou égal à 18 et strictement inférieur à 100.
+type Age = (
+	& number
+	& DNumber.Integer
+	& DNumber.StrictPositive
+	& DNumber.GreaterThanOrEqual<18>
+	& DNumber.LessThan<100>
+);
+
+// Tableau de 1 à 15 éléments, dont chaque élément respecte aussi son contrat.
+type Friends = (
+	& {
+		name: Name;
+		age: Age;
+	}[]
+	& DArray.MinElements<1>
+	& DArray.MaxElements<15>
+);

package/docs/concepts/01-fundamental/01-constraint/20-manipulation.ts

@@ -0,0 +1,41 @@
+/**
+ * @title Manipulation des valeurs contraintes.
+ *
+ * Exploitation des contraintes par les fonctions DuploJS pour simplifier la manipulation des valeurs.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DTuple from "@duplojs/lang/tuple";
+import * as DString from "@duplojs/lang/string";
+import * as DArray from "@duplojs/lang/array";
+
+// Les primitives exploitent les garanties d’entrée pour préciser leur sortie.
+// Une transformation conserve, adapte ou supprime les contraintes selon ce qui reste vrai.
+declare const userEmail: string & DString.Email;
+
+// Un email dans son format contenant obligatoirement un "@"
+// donne forcément un tableau avec minimum 2 éléments.
+const splitEmail = DString.split(userEmail, "@");
+type _CheckSplitEmail = DCommon.ExpectType<typeof splitEmail, readonly string[] & DArray.MinElements<2>, "strict">;
+
+// Le passage du tableau en tuple est fait en interprétant la contrainte
+// DArray.MinElements<2>, ce qui garantit au moins deux éléments, sans imposer une longueur exacte.
+const [first, second, ...maybeRest] = DTuple.from(splitEmail);
+type _CheckFirst = DCommon.ExpectType<typeof first, string, "strict">;
+type _CheckSecond = DCommon.ExpectType<typeof second, string, "strict">;
+type _CheckMaybeRest = DCommon.ExpectType<typeof maybeRest, string[], "strict">;
+
+// Les accès garantis par la cardinalité évitent le type string | undefined.
+const firstElement = DArray.first(splitEmail);
+type _CheckFirstElement = DCommon.ExpectType<typeof firstElement, string, "strict">;
+
+const lastElement = DArray.last(splitEmail);
+type _CheckLastElement = DCommon.ExpectType<typeof lastElement, string, "strict">;
+
+const secondElement = DArray.at(splitEmail, 1);
+type _CheckSecondElement = DCommon.ExpectType<typeof secondElement, string, "strict">;
+
+const otherElement = DArray.at(splitEmail, 10);
+type _CheckOtherElement = DCommon.ExpectType<typeof otherElement, string | undefined, "strict">;
+
+// Le résultat porte une garantie de cardinalité ; les fragments ne sont plus typés Email.
+// Privilégier les transformations immuables : une mutation pourrait invalider une garantie.

package/docs/concepts/01-fundamental/01-constraint/30-cast.ts

@@ -0,0 +1,66 @@
+/**
+ * @title Compatibilité statique des contraintes.
+ *
+ * Cast par implication, valeurs littérales et inférence en contexte générique.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import type * as DString from "@duplojs/lang/string";
+
+// cast restitue la valeur sans validation runtime : TypeScript doit prouver la compatibilité.
+// Il convertit une garantie existante, ou exploite une valeur connue statiquement.
+// Une donnée runtime sans preuve doit d’abord être vérifiée par un predicate.
+declare function myFunction(name: string & DString.MinCharacters<10>): void;
+
+declare const validName: string & DString.MinCharacters<15>;
+// Au moins 15 caractères implique au moins 10 caractères.
+myFunction(DCommon.cast(validName));
+
+declare const invalidName: string & DString.MinCharacters<5>;
+// Erreur de type car la contrainte `DString.MinCharacters<5>`
+// n'induit pas `string & DString.MinCharacters<10>`
+// @ts-expect-error constraint error
+myFunction(DCommon.cast(invalidName));
+
+// De même, une borne strictement inférieure à 10 implique une borne inférieure à 20.
+declare const belowTen: number & DNumber.LessThan<10>;
+const belowTwenty: number & DNumber.LessThan<20> = DCommon.cast(belowTen);
+
+// Les valeurs littérales permettent aussi de calculer la compatibilité sans validation.
+const declaredName: string & DString.MinCharacters<10> = DCommon.cast("thisIsASuperName");
+const declaredAge: number & DNumber.GreaterThanOrEqual<18> = DCommon.cast(20);
+
+declare function myFunctionWithGeneric<
+	GenericName extends string & DString.MinCharacters<10>,
+>(name: GenericName): void;
+
+// Ici, le paramètre générique ne fournit pas à cast un type de retour assez précis.
+// satisfies explicite la cible pour permettre le calcul de compatibilité.
+myFunctionWithGeneric(
+	DCommon.cast("thisIsASuperName") satisfies string & DString.MinCharacters<10>,
+);
+
+// @ts-expect-error cast ne peut pas inférer ici le type de retour attendu.
+myFunctionWithGeneric(DCommon.cast("thisIsASuperName"));
+
+declare function createUser<
+	GenericUser extends {
+		name: string & DString.MinCharacters<10>;
+		age: number & DNumber.GreaterThanOrEqual<18>;
+	},
+>(name: GenericUser): GenericUser;
+
+// infer calcule les contraintes attendues tout en conservant la valeur littérale.
+// Il est adapté aux constantes connues statiquement et ne valide rien au runtime.
+const inferredUser = createUser({
+	name: DCommon.infer("thisIsASuperName"),
+	age: DCommon.infer(18),
+});
+type _CheckInferredUser = DCommon.ExpectType<
+	typeof inferredUser,
+	{
+		name: "thisIsASuperName" & DString.MinCharacters<10>;
+		age: 18 & DNumber.GreaterThanOrEqual<18>;
+	},
+	"strict"
+>;

package/docs/concepts/01-fundamental/01-constraint/40-custom-constraint.ts

@@ -0,0 +1,45 @@
+/**
+ * @title Contraintes personnalisées.
+ *
+ * Déclaration, predicate de validation et extension des règles de cast.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+// Étendre Constraint avec un identifiant propre à la propriété modélisée.
+// Cette interface n’ajoute aucun marqueur à la valeur runtime.
+interface Adult extends DCommon.Constraint<"example-adult"> {}
+
+// La signature du predicate doit correspondre à une vérification réelle.
+function isAdult(input: number): input is number & Adult {
+	return DNumber.greaterThanOrEqual(input, 18);
+}
+
+declare const candidate: number;
+if (isAdult(candidate)) {
+	const adult: number & Adult = candidate;
+}
+
+// Les règles de cast peuvent être étendues par augmentation du module common.
+// Cette règle reconnaît la preuve GreaterThanOrEqual<18> comme suffisante pour Adult.
+// Elle ne couvre volontairement pas toutes les autres bornes compatibles.
+declare module "@duplojs/lang/common" {
+	interface ComputeCastConstraintNumberRule<
+		GenericValue extends number,
+		GenericExpectedConstraint extends DCommon.BaseConstraint,
+	> {
+		exampleAdult: GenericExpectedConstraint extends Adult
+			? GenericValue extends DNumber.GreaterThanOrEqual<18>
+				? unknown
+				: DCommon.CastError<"La preuve de majorité est absente.", GenericValue, GenericExpectedConstraint>
+			: never;
+	}
+}
+
+// unknown accepte la compatibilité, CastError la refuse, never ignore les autres cibles.
+// Consulter les interfaces de règles existantes pour étendre les autres domaines.
+declare const verifiedAge: number & DNumber.GreaterThanOrEqual<18>;
+const adultFromProof: number & Adult = DCommon.cast(verifiedAge);
+
+// @ts-expect-error Un nombre sans preuve ne peut pas être converti en Adult.
+const adultWithoutProof: number & Adult = DCommon.cast(candidate);

package/docs/concepts/01-fundamental/01-constraint/index.md

@@ -0,0 +1,3 @@
+## Contraintes de typage
+
+Garanties sur les valeurs : acquisition, composition, propagation, compatibilité statique et contraintes personnalisées.

package/docs/concepts/01-fundamental/02-currying/01-use.ts

@@ -0,0 +1,38 @@
+/**
+ * @title Currification et composition avec pipe.
+ *
+ * Configurer les opérations avant de recevoir la donnée et enchaîner ses transformations.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+
+// La forme curifiée reçoit les paramètres, puis la donnée transmise par pipe.
+// Si la fonction retournée ne déclare pas ses propres génériques, ses types sont
+// fixés dès l'appel de configuration, même si la surcharge extérieure est générique.
+// Écrire alors l'appel curifié directement comme étape de pipe ou asyncPipe pour
+// fournir le contexte d'inférence attendu. Passer à un pipe une variable contenant
+// une fonction déjà préparée ne déplace pas sa configuration dans ce contexte.
+// Ne pas forcer cette préparation avec des génériques explicites, annotations ou casts.
+// Formater chaque pipe sur plusieurs lignes, un argument par ligne et la fermeture
+// sur sa propre ligne, même avec seulement une donnée et une étape.
+// Privilégier pipe dès qu’une donnée subit plusieurs transformations,
+// ou si le traitement est susceptible d’en accueillir d’autres.
+// Utiliser en priorité les fonctions fournies par l’écosystème.
+const normalizedTags = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	// Configure le séparateur ; pipe fournit ensuite la chaîne.
+	DString.split(","),
+	// Configure la transformation ; pipe fournit le tableau.
+	DArray.map(DString.trim),
+	DArray.filter(DString.isNotEmpty),
+	DArray.map(DString.toLowerCase),
+);
+type _CheckNormalizedTags = DCommon.ExpectType<
+	typeof normalizedTags,
+	readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<3>,
+	"strict"
+>;
+// Résultat : ["typescript", "duplojs", "functional"].
+// Chaque étape reçoit la sortie précédente ; les types suivent ces transformations.
+// On peut ajouter, retirer ou réordonner les étapes sans restructurer le traitement.

package/docs/concepts/01-fundamental/02-currying/10-built-in-function.ts

@@ -0,0 +1,190 @@
+/**
+ * @title Réutilisation des fonctions de l’écosystème dans les pipes.
+ *
+ * Composer les opérations fournies, sous forme curifiée ou directement compatible avec pipe.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+import * as DObject from "@duplojs/lang/object";
+import * as DNumber from "@duplojs/lang/number";
+import * as DEither from "@duplojs/lang/either";
+import * as DTuple from "@duplojs/lang/tuple";
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DGenerator from "@duplojs/lang/generator";
+import * as DPattern from "@duplojs/lang/pattern";
+import type * as DPath from "@duplojs/lang/path";
+import * as DSFile from "@duplojs/server/file";
+
+// Avant d’écrire une callback ou de recourir à une API native, rechercher une opération
+// fournie par l’écosystème : sa forme curifiée ou son unique argument peut convenir au pipe.
+// Cette démarche s’applique à tous les packages ; les domaines ci-dessous sont des exemples.
+
+// Les fonctions de `string` et `array` sont faites pour être composées.
+const normalizedNames = DCommon.pipe(
+	[" John ", "", " JANE ", " Alice "],
+	DArray.map(DString.trim),
+	DArray.filter(DString.isNotEmpty),
+	DArray.map(DString.toLowerCase),
+	DArray.sort(DString.sortCompare),
+);
+type _CheckNormalizedNames = DCommon.ExpectType<
+	typeof normalizedNames,
+	readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<4>,
+	"strict"
+>;
+
+// Les prédicats de `number` peuvent directement être utilisés
+// dans les fonctions de manipulation de tableaux.
+const adultAges = DCommon.pipe(
+	[12, 18, 42, 8, 21],
+	DArray.filter(DNumber.greaterThanOrEqual(18)),
+	DNumber.sum,
+);
+type _CheckAdultAges = DCommon.ExpectType<typeof adultAges, number, "strict">;
+
+// Les fonctions de `object` sont également prévues pour le pipe.
+const publicUser = DCommon.pipe(
+	{
+		name: " John ",
+		password: "secret",
+		age: 24,
+	},
+	DObject.transformProperty("name", DString.trim),
+	DObject.omit(["password"]),
+);
+type _CheckPublicUser = DCommon.ExpectType<
+	typeof publicUser,
+	{
+		name: string & DString.Trimmed & DString.MaxCharacters<6>;
+		readonly age: 24;
+	},
+	"strict"
+>;
+
+// `innerPipe` permet de composer plusieurs fonctions intégrées
+// directement à l'endroit où une callback est attendue.
+const users = DCommon.pipe(
+	[
+		{
+			name: " John ",
+			age: 24,
+		},
+		{
+			name: " JANE ",
+			age: 32,
+		},
+	],
+	DArray.map(
+		DCommon.innerPipe(
+			DObject.transformProperty(
+				"name",
+				DCommon.innerPipe(
+					DString.trim,
+					DString.toLowerCase,
+				),
+			),
+			DObject.pick(["name"]),
+		),
+	),
+);
+type _CheckUsers = DCommon.ExpectType<
+	typeof users,
+	readonly { name: Lowercase<string> }[] & DArray.LengthEqual<2>,
+	"strict"
+>;
+
+// Les fonctions `Either` sont elles aussi composables avec les pipes.
+declare const maybeName:
+	| DEither.Right<"user-found", string>
+	| DEither.Left<"user-not-found">;
+
+const name = DCommon.pipe(
+	maybeName,
+	DEither.unwrapOr("anonymous"),
+	DString.trim,
+	DString.toLowerCase,
+);
+type _CheckName = DCommon.ExpectType<typeof name, Lowercase<string>, "strict">;
+
+// `Either` possède également ses propres pipes lorsque le traitement
+// doit continuer uniquement sur une valeur `Right`.
+const normalizedEitherName = DEither.rightPipe(
+	maybeName,
+	DString.trim,
+	DString.toLowerCase,
+);
+type _CheckNormalizedEitherName = DCommon.ExpectType<typeof normalizedEitherName, DEither.Left<"user-not-found", unknown> | DEither.Success<Lowercase<string>>, "strict">;
+
+// Les tuples disposent eux aussi de fonctions curifiées.
+const normalizedTuple = DCommon.pipe(
+	[" John ", " Jane "] as const,
+	DTuple.map(DString.trim),
+);
+type _CheckNormalizedTuple = DCommon.ExpectType<typeof normalizedTuple, readonly [string & DString.Trimmed & DString.MaxCharacters<6>, string & DString.Trimmed & DString.MaxCharacters<6>], "strict">;
+
+// Les generators permettent de construire des transformations lazy
+// avec exactement le même modèle de composition.
+const generatedNames = DCommon.pipe(
+	[" John ", "", " JANE ", " Alice "],
+	DGenerator.map(DString.trim),
+	DGenerator.filter(DString.isNotEmpty),
+	DGenerator.map(DString.toLowerCase),
+	DArray.from,
+);
+type _CheckGeneratedNames = DCommon.ExpectType<typeof generatedNames, readonly (Lowercase<string> & DString.MinCharacters<1>)[], "strict">;
+
+// Les fonctions de date peuvent être utilisées directement dans les pipes.
+declare const creationDate: DChrono.TheDate;
+
+const serializedCreationDate = DCommon.pipe(
+	creationDate,
+	DChrono.formatDate(
+		"YYYY-MM-DD HH:mm:ss",
+		"Europe/Paris",
+	),
+);
+type _CheckSerializedCreationDate = DCommon.ExpectType<typeof serializedCreationDate, string, "strict">;
+
+// Le pattern matching fournit également des fonctions curifiées.
+declare const status: "draft" | "published" | "archived";
+
+const statusLabel = DCommon.pipe(
+	status,
+	DPattern.matchWithStringOtherwise(
+		{
+			draft: () => "Draft" as const,
+			published: () => "Published" as const,
+		},
+		() => "Archived" as const,
+	),
+);
+type _CheckStatusLabel = DCommon.ExpectType<typeof statusLabel, "Draft" | "Published" | "Archived", "strict">;
+
+// Les fonctions n'ont pas besoin d'être curifiées lorsqu'elles reçoivent
+// déjà la donnée comme unique argument : elles peuvent être utilisées
+// directement comme étape du pipe.
+declare const filePath: string & DPath.Path;
+
+const fileContent = await DCommon.asyncPipe(
+	filePath,
+	DSFile.readTextFile,
+	DEither.unwrapOr(""),
+	DString.trim,
+);
+type _CheckFileContent = DCommon.ExpectType<typeof fileContent, string & DString.Trimmed, "strict">;
+
+// Les fonctions curifiées existent également dans `@duplojs/server`.
+const writeResult = await DCommon.asyncPipe(
+	filePath,
+	DSFile.writeTextFile("Hello world"),
+);
+type _CheckWriteResult = DCommon.ExpectType<typeof writeResult, DSFile.WriteTextFileResult, "strict">;
+
+// Cela permet de composer des traitements provenant de plusieurs packages.
+const jsonContent = await DCommon.asyncPipe(
+	filePath,
+	DSFile.readJsonFile,
+	DEither.unwrapOr({}),
+);
+type _CheckJsonContent = DCommon.ExpectType<typeof jsonContent, DCommon.Json | {}, "strict">;

package/docs/concepts/01-fundamental/02-currying/20-inner-pipe.ts

@@ -0,0 +1,48 @@
+/**
+ * @title Composition dans une callback.
+ *
+ * Enchaîner des transformations lorsque la fonction appelante attend une fonction.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import * as DString from "@duplojs/lang/string";
+import type * as DNumber from "@duplojs/lang/number";
+
+// `innerPipe` permet d'enchaîner plusieurs transformations lorsqu'une
+// fonction de transformation est elle-même attendue.
+//
+const normalizedTagsWithInnerPipe = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	DString.split(","),
+	DArray.map(
+		DCommon.innerPipe(
+			DString.trim,
+			DString.toLowerCase,
+		),
+	),
+	DArray.filter(DString.isNotEmpty),
+);
+type _CheckNormalizedTagsWithInnerPipe = DCommon.ExpectType<
+	typeof normalizedTagsWithInnerPipe,
+	readonly (Lowercase<string> & DString.NotEmpty)[] & DArray.MaxElements<3>,
+	"strict"
+>;
+
+// `innerPipe` évite de créer une callback intermédiaire uniquement
+// pour enchaîner plusieurs transformations.
+//
+const tagLengths = DCommon.pipe(
+	" TypeScript, DuploJS, Functional " as const,
+	DString.split(","),
+	DArray.map(
+		DCommon.innerPipe(
+			DString.trim,
+			DString.length,
+		),
+	),
+);
+type _CheckTagLengths = DCommon.ExpectType<
+	typeof tagLengths,
+	readonly (number & DNumber.Positive)[] & DArray.LengthEqual<3> & DArray.MinElements<3> & DArray.MaxElements<3>,
+	"strict"
+>;