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

package/docs/API/60-playwright/30-assertions/10-toBeEnabled.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toBeEnabled
+ *
+ * Vérifier qu’un élément visible est activé.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { searchForm } from "../fixtures/component";
+
+await Assertions.toBeEnabled(searchForm, "submit");

package/docs/API/60-playwright/30-assertions/10-toBeHidden.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toBeHidden
+ *
+ * Vérifier que l’élément est caché.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { navigation } from "../fixtures/component";
+
+await Assertions.toBeHidden(navigation, "menu");

package/docs/API/60-playwright/30-assertions/10-toBeNotBusy.ts

@@ -0,0 +1,10 @@
+/**
+ * @title Assertions.toBeNotBusy
+ *
+ * Vérifier aria-busy="false" sur un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { articleList } from "../fixtures/component";
+
+// Exige aria-busy="false", et non simplement l’absence de l’attribut.
+await Assertions.toBeNotBusy(articleList, "loading");

package/docs/API/60-playwright/30-assertions/10-toBeVisible.ts

@@ -0,0 +1,10 @@
+/**
+ * @title Assertions.toBeVisible
+ *
+ * Faire défiler jusqu’à l’élément puis vérifier sa visibilité.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { navigation } from "../fixtures/component";
+
+// L’élément est d’abord défilé dans la vue, puis sa visibilité est vérifiée.
+await Assertions.toBeVisible(navigation, "menu");

package/docs/API/60-playwright/30-assertions/10-toContainText.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toContainText
+ *
+ * Vérifier une partie du texte d’un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { articleList } from "../fixtures/component";
+
+await Assertions.toContainText(articleList, "title", /TypeScript/);

package/docs/API/60-playwright/30-assertions/10-toHaveAttribute.ts

@@ -0,0 +1,12 @@
+/**
+ * @title Assertions.toHaveAttribute
+ *
+ * Vérifier un attribut d’un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { navigation } from "../fixtures/component";
+
+await Assertions.toHaveAttribute(navigation, "menuButton", "aria-expanded", "true");
+
+// Sans valeur, l’attribut doit correspondre à /.+/ : une valeur vide ne suffit pas.
+await Assertions.toHaveAttribute(navigation, "menuButton", "aria-controls");

package/docs/API/60-playwright/30-assertions/10-toHaveClass.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toHaveClass
+ *
+ * Vérifier les classes d’un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { navigation } from "../fixtures/component";
+
+await Assertions.toHaveClass(navigation, "menuButton", /active/);

package/docs/API/60-playwright/30-assertions/10-toHaveNoText.ts

@@ -0,0 +1,10 @@
+/**
+ * @title Assertions.toHaveNoText
+ *
+ * Vérifier que le texte d’un élément visible est vide.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { searchForm } from "../fixtures/component";
+
+// Le message visible doit avoir un texte vide.
+await Assertions.toHaveNoText(searchForm, "feedback");

package/docs/API/60-playwright/30-assertions/10-toHaveQuantity.ts

@@ -0,0 +1,20 @@
+/**
+ * @title Assertions.toHaveQuantity
+ *
+ * Vérifier le nombre d’éléments correspondants.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { articleList } from "../fixtures/component";
+
+// Sans opérateur, ou avec "e", le nombre doit être exact.
+await Assertions.toHaveQuantity(articleList, "articles", { quantity: 2 });
+
+// Les bornes sont inclusives ; le comptage est réessayé pendant 5 secondes au plus.
+await Assertions.toHaveQuantity(articleList, "articles", {
+	quantity: 1,
+	operator: "gte",
+});
+await Assertions.toHaveQuantity(articleList, "articles", {
+	quantity: 3,
+	operator: "lte",
+});

package/docs/API/60-playwright/30-assertions/10-toHaveText.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toHaveText
+ *
+ * Vérifier le texte complet d’un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { articleList } from "../fixtures/component";
+
+await Assertions.toHaveText(articleList, "title", "Introduction à TypeScript");

package/docs/API/60-playwright/30-assertions/10-toHaveValue.ts

@@ -0,0 +1,9 @@
+/**
+ * @title Assertions.toHaveValue
+ *
+ * Vérifier la valeur d’un élément visible.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { searchForm } from "../fixtures/component";
+
+await Assertions.toHaveValue(searchForm, "query", "TypeScript");

package/docs/API/60-playwright/30-assertions/10-withStep.ts

@@ -0,0 +1,10 @@
+/**
+ * @title Assertions.withStep
+ *
+ * Ajouter une étape Playwright nommée autour d’une interaction.
+ */
+import { Assertions } from "@duplojs/playwright";
+import { searchForm } from "../fixtures/component";
+
+// Cette étape englobe celle produite par l’assertion dans le rapport Playwright.
+await Assertions.withStep("Vérifier la recherche").toBeEnabled(searchForm, "submit");

package/docs/API/60-playwright/30-assertions/index.llms.md

@@ -0,0 +1,64 @@
+## Assertions
+
+Vérifications de l’état des éléments nommés des pages et composants.
+
+### [Assertions.toBeBusy](10-toBeBusy.ts)
+
+Vérifier aria-busy="true" sur un élément visible.
+ 
+### [Assertions.toBeChecked](10-toBeChecked.ts)
+
+Vérifier qu’un élément visible est coché.
+ 
+### [Assertions.toBeDisabled](10-toBeDisabled.ts)
+
+Vérifier qu’un élément visible est désactivé.
+ 
+### [Assertions.toBeEnabled](10-toBeEnabled.ts)
+
+Vérifier qu’un élément visible est activé.
+ 
+### [Assertions.toBeHidden](10-toBeHidden.ts)
+
+Vérifier que l’élément est caché.
+ 
+### [Assertions.toBeNotBusy](10-toBeNotBusy.ts)
+
+Vérifier aria-busy="false" sur un élément visible.
+ 
+### [Assertions.toBeVisible](10-toBeVisible.ts)
+
+Faire défiler jusqu’à l’élément puis vérifier sa visibilité.
+ 
+### [Assertions.toContainText](10-toContainText.ts)
+
+Vérifier une partie du texte d’un élément visible.
+ 
+### [Assertions.toHaveAttribute](10-toHaveAttribute.ts)
+
+Vérifier un attribut d’un élément visible.
+ 
+### [Assertions.toHaveClass](10-toHaveClass.ts)
+
+Vérifier les classes d’un élément visible.
+ 
+### [Assertions.toHaveNoText](10-toHaveNoText.ts)
+
+Vérifier que le texte d’un élément visible est vide.
+ 
+### [Assertions.toHaveQuantity](10-toHaveQuantity.ts)
+
+Vérifier le nombre d’éléments correspondants.
+ 
+### [Assertions.toHaveText](10-toHaveText.ts)
+
+Vérifier le texte complet d’un élément visible.
+ 
+### [Assertions.toHaveValue](10-toHaveValue.ts)
+
+Vérifier la valeur d’un élément visible.
+ 
+### [Assertions.withStep](10-withStep.ts)
+
+Ajouter une étape Playwright nommée autour d’une interaction.
+ 

package/docs/API/60-playwright/30-assertions/index.md

@@ -0,0 +1,3 @@
+## Assertions
+
+Vérifications de l’état des éléments nommés des pages et composants.

package/docs/API/60-playwright/fixtures/component.ts

@@ -0,0 +1,44 @@
+import { createComponent, type Website } from "@duplojs/playwright";
+
+declare const website: Website;
+
+const searchFormEngine = createComponent("search form", {
+	getMainElement: ({ body }) => body.locator("form[data-search]"),
+	getElements: ({ mainElement }) => ({
+		query: mainElement.locator("input[name='query']"),
+		submit: mainElement.locator("button[type='submit']"),
+		onlyPublished: mainElement.locator("input[name='published']"),
+		categories: mainElement.locator("select[name='categories'][multiple]"),
+		feedback: mainElement.locator("[role='status']"),
+	}),
+});
+
+const articleListEngine = createComponent("article list", {
+	getMainElement: ({ body }) => body.locator("[data-article-list]"),
+	getElements: ({ mainElement }) => ({
+		articles: mainElement.locator("article"),
+		title: mainElement.locator("h2").first(),
+		loading: mainElement.locator("[data-loading]"),
+	}),
+});
+
+const navigationEngine = createComponent("navigation", {
+	getMainElement: ({ body }) => body.locator("nav"),
+	getElements: ({ mainElement }) => ({
+		menuButton: mainElement.locator("button[data-menu]"),
+		menu: mainElement.locator("[data-menu-items]"),
+	}),
+});
+
+const boardEngine = createComponent("kanban board", {
+	getMainElement: ({ body }) => body.locator("[data-board]"),
+	getElements: ({ mainElement }) => ({
+		task: mainElement.locator("[data-task='review']"),
+		doneColumn: mainElement.locator("[data-column='done']"),
+	}),
+});
+
+export const searchForm = searchFormEngine(website);
+export const articleList = articleListEngine(website);
+export const navigation = navigationEngine(website);
+export const board = boardEngine(website);

package/docs/API/60-playwright/index.md

@@ -0,0 +1,3 @@
+# @duplojs/playwright
+
+Fabriques de site, pages et composants, interactions et assertions pour les parcours E2E.

package/docs/API.llms.md

@@ -29,3 +29,87 @@ Création, discrimination, transformation et propagation des réussites ou des
 ## [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/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/20-manipulation.ts

@@ -3,6 +3,7 @@
  *
  * 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";
@@ -13,26 +14,28 @@ declare const userEmail: string & DString.Email;
 
 // Un email dans son format contenant obligatoirement un "@"
 // donne forcément un tableau avec minimum 2 éléments.
-// readonly string[] & DArray.MinElements<2>
 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.
-// readonly [string, string, ...string[]]
 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.
-// string
 const firstElement = DArray.first(splitEmail);
+type _CheckFirstElement = DCommon.ExpectType<typeof firstElement, string, "strict">;
 
-// string
 const lastElement = DArray.last(splitEmail);
+type _CheckLastElement = DCommon.ExpectType<typeof lastElement, string, "strict">;
 
-// string
 const secondElement = DArray.at(splitEmail, 1);
+type _CheckSecondElement = DCommon.ExpectType<typeof secondElement, string, "strict">;
 
-// string | undefined
 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

@@ -52,11 +52,15 @@ declare function createUser<
 
 // 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.
-createUser({
+const inferredUser = createUser({
 	name: DCommon.infer("thisIsASuperName"),
 	age: DCommon.infer(18),
 });
-// {
-//     name: "thisIsASuperName" & DString.MinCharacters<10>;
-//     age: 18 & DNumber.GreaterThanOrEqual<18>;
-// }
+type _CheckInferredUser = DCommon.ExpectType<
+	typeof inferredUser,
+	{
+		name: "thisIsASuperName" & DString.MinCharacters<10>;
+		age: 18 & DNumber.GreaterThanOrEqual<18>;
+	},
+	"strict"
+>;

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

@@ -28,6 +28,11 @@ const normalizedTags = DCommon.pipe(
 	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

@@ -21,7 +21,6 @@ import * as DSFile from "@duplojs/server/file";
 // 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.
-// readonly (Lowercase<string> & DString.MinCharacters<1>)[] & DArray.MaxElements<4>
 const normalizedNames = DCommon.pipe(
 	[" John ", "", " JANE ", " Alice "],
 	DArray.map(DString.trim),
@@ -29,21 +28,22 @@ const normalizedNames = DCommon.pipe(
 	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.
-// number
 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.
-// {
-//     name: string & DString.Trimmed & DString.MaxCharacters<6>;
-//     readonly age: 24;
-// }
 const publicUser = DCommon.pipe(
 	{
 		name: " John ",
@@ -53,10 +53,17 @@ const publicUser = DCommon.pipe(
 	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.
-// readonly { name: Lowercase<string>; }[] & DArray.LengthEqual<2>
 const users = DCommon.pipe(
 	[
 		{
@@ -81,39 +88,43 @@ const users = DCommon.pipe(
 		),
 	),
 );
+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">;
 
-// Lowercase<string>
 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`.
-// DEither.Left<"user-not-found", unknown> | DEither.Success<Lowercase<string>>
 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.
-// readonly [string & DString.Trimmed & DString.MaxCharacters<6>, string & DString.Trimmed & DString.MaxCharacters<6>]
 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.
-// readonly (Lowercase<string> & DString.MinCharacters<1>)[]
 const generatedNames = DCommon.pipe(
 	[" John ", "", " JANE ", " Alice "],
 	DGenerator.map(DString.trim),
@@ -121,11 +132,11 @@ const generatedNames = DCommon.pipe(
 	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;
 
-// string
 const serializedCreationDate = DCommon.pipe(
 	creationDate,
 	DChrono.formatDate(
@@ -133,11 +144,11 @@ const serializedCreationDate = DCommon.pipe(
 		"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";
 
-// "Draft" | "Published" | "Archived"
 const statusLabel = DCommon.pipe(
 	status,
 	DPattern.matchWithStringOtherwise(
@@ -148,31 +159,32 @@ const statusLabel = DCommon.pipe(
 		() => "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;
 
-// string & DString.Trimmed
 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`.
-// DSFile.WriteTextFileResult
 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.
-// DCommon.Json | {}
 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

@@ -6,11 +6,11 @@
 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.
 //
-// readonly (Lowercase<string> & DString.NotEmpty)[] & DArray.MaxElements<3>
 const normalizedTagsWithInnerPipe = DCommon.pipe(
 	" TypeScript, DuploJS, Functional " as const,
 	DString.split(","),
@@ -22,11 +22,15 @@ const normalizedTagsWithInnerPipe = DCommon.pipe(
 	),
 	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.
 //
-// readonly (number & Positive)[] & DArray.LengthEqual<3> & DArray.MinElements<3> & DArray.MaxElements<3>
 const tagLengths = DCommon.pipe(
 	" TypeScript, DuploJS, Functional " as const,
 	DString.split(","),
@@ -37,3 +41,8 @@ const tagLengths = DCommon.pipe(
 		),
 	),
 );
+type _CheckTagLengths = DCommon.ExpectType<
+	typeof tagLengths,
+	readonly (number & DNumber.Positive)[] & DArray.LengthEqual<3> & DArray.MinElements<3> & DArray.MaxElements<3>,
+	"strict"
+>;