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

package/docs/API/10-lang/10-chrono/10-subtractTime.ts

@@ -0,0 +1,38 @@
+/**
+ * @title DChrono.subtractTime
+ *
+ * Soustraire une durée à une date ou à une autre durée en conservant la nature de l’entrée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const dateResult = DChrono.subtractTime("date1000+", "time500+");
+const timeResult = DChrono.subtractTime("time1000+", "time500+");
+
+// Une date reste une TheDate et une durée reste une TheTime.
+type _CheckDate = DCommon.ExpectType<typeof dateResult, DChrono.TheDate, "strict">;
+type _CheckTime = DCommon.ExpectType<typeof timeResult, DChrono.TheTime, "strict">;
+
+// La forme curifiée s’applique aussi dans un pipe.
+const piped = DCommon.pipe(
+	"date1000+",
+	DChrono.subtractTime("time500+"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Les instances TheDate et TheTime peuvent être combinées avec une TheTime.
+const dateInstanceResult = DChrono.subtractTime(
+	DChrono.createDate("2021-01-01"),
+	DChrono.createTimeOrThrow(1_000),
+);
+const timeInstanceResult = DChrono.subtractTime(
+	DChrono.createTimeOrThrow(1_000),
+	DChrono.createTimeOrThrow(500),
+);
+
+type _CheckInstances = DCommon.ExpectType<
+	[typeof dateInstanceResult, typeof timeInstanceResult],
+	[DChrono.TheDate, DChrono.TheTime],
+	"strict"
+>;
+

package/docs/API/10-lang/10-chrono/10-subtractWeeks.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractWeeks
+ *
+ * Soustraire un nombre de semaines à une date.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.subtractWeeks(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 week vers le passé.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.subtractWeeks(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractWeeks("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-subtractYears.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractYears
+ *
+ * Soustraire un nombre d’années à une date en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const result = DChrono.subtractYears(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 year vers le passé.
+type _CheckResult = DCommon.ExpectType<typeof result, DChrono.TheDate, "strict">;
+
+// La forme curifiée fixe le décalage dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.subtractYears(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractYears("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-toDateISOString.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DChrono.toDateISOString
+ *
+ * Convertir une date en chaîne ISO UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const iso = DChrono.toDateISOString(DChrono.createDate("2021-01-01"));
+
+// La valeur obtenue est « 2021-01-01T00:00:00.000Z ».
+type _CheckIso = DCommon.ExpectType<typeof iso, string, "strict">;
+
+// Une date sérialisée est convertie de la même manière.
+const serializedIso = DChrono.toDateISOString("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedIso, string, "strict">;
+

package/docs/API/10-lang/10-chrono/10-toNative.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.toNative
+ *
+ * Convertir une TheDate en Date native ou une TheTime en nombre de millisecondes.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const nativeDate = DChrono.toNative(DChrono.createDate("2021-01-01"));
+const nativeTime = DChrono.toNative(DChrono.createTimeOrThrow(2_500));
+
+// La surcharge choisie par l’entrée produit respectivement Date et number.
+type _CheckDate = DCommon.ExpectType<typeof nativeDate, Date, "strict">;
+type _CheckTime = DCommon.ExpectType<typeof nativeTime, number, "strict">;
+
+// Les formes sérialisées sélectionnent les mêmes surcharges selon leur préfixe.
+const nativeSerializedDate = DChrono.toNative("date1609459200000+");
+const nativeSerializedTime = DChrono.toNative("time2500+");
+
+type _CheckSerialized = DCommon.ExpectType<
+	[typeof nativeSerializedDate, typeof nativeSerializedTime],
+	[Date, number],
+	"strict"
+>;
+

package/docs/API/10-lang/10-chrono/10-toTimeValue.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DChrono.toTimeValue
+ *
+ * Lire la valeur en millisecondes d’une TheTime ou d’une chaîne sérialisée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const value = DChrono.toTimeValue(DChrono.createTimeOrThrow(2_500));
+
+// La valeur obtenue est 2 500.
+type _CheckValue = DCommon.ExpectType<typeof value, number, "strict">;
+
+// Une durée sérialisée produit la même valeur en millisecondes.
+const serializedValue = DChrono.toTimeValue("time2500+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedValue, number, "strict">;
+

package/docs/API/10-lang/10-chrono/10-toTimestamp.ts

@@ -0,0 +1,17 @@
+/**
+ * @title DChrono.toTimestamp
+ *
+ * Lire le timestamp en millisecondes d’une TheDate ou d’une chaîne sérialisée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const timestamp = DChrono.toTimestamp(DChrono.createDate("2021-01-01"));
+
+// La valeur obtenue représente 2021-01-01T00:00:00.000Z en millisecondes.
+type _CheckTimestamp = DCommon.ExpectType<typeof timestamp, number, "strict">;
+
+// Une date sérialisée produit le même timestamp.
+const serializedTimestamp = DChrono.toTimestamp("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedTimestamp, number, "strict">;
+

package/docs/API/10-lang/10-chrono/10-today.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DChrono.today
+ *
+ * Créer une TheDate correspondant au début du jour courant en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const currentDay = DChrono.today();
+
+// La valeur dépend de la date courante, mais son heure UTC est ramenée à minuit.
+type _CheckCurrentDay = DCommon.ExpectType<typeof currentDay, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-tomorrow.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DChrono.tomorrow
+ *
+ * Créer une TheDate correspondant au début du jour suivant en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const nextDay = DChrono.tomorrow();
+
+// La valeur dépend de l’horloge, mais représente le jour suivant à minuit UTC.
+type _CheckNextDay = DCommon.ExpectType<typeof nextDay, DChrono.TheDate, "strict">;
+

package/docs/API/10-lang/10-chrono/10-yesterday.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DChrono.yesterday
+ *
+ * Créer une TheDate correspondant au début du jour précédent en UTC.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const previousDay = DChrono.yesterday();
+
+// La valeur dépend de l’horloge, mais représente le jour précédent à minuit UTC.
+type _CheckPreviousDay = DCommon.ExpectType<typeof previousDay, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,332 @@
+## DChrono
+
+Création, calcul, comparaison, sérialisation et formatage des dates, heures, durées et fuseaux horaires dans les représentations Chrono de DuploJS.
+
+### [DChrono.addDays](10-addDays.ts)
+
+Ajouter un nombre de jours à une date.
+ 
+### [DChrono.addHours](10-addHours.ts)
+
+Ajouter un nombre d’heures à une date.
+ 
+### [DChrono.addMilliseconds](10-addMilliseconds.ts)
+
+Ajouter un nombre de millisecondes à une date.
+ 
+### [DChrono.addMinutes](10-addMinutes.ts)
+
+Ajouter un nombre de minutes à une date.
+ 
+### [DChrono.addMonths](10-addMonths.ts)
+
+Ajouter un nombre de mois à une date en UTC.
+ 
+### [DChrono.addSeconds](10-addSeconds.ts)
+
+Ajouter un nombre de secondes à une date.
+ 
+### [DChrono.addTime](10-addTime.ts)
+
+Ajouter une durée à une date ou à une autre durée en conservant la nature de l’entrée.
+ 
+### [DChrono.addWeeks](10-addWeeks.ts)
+
+Ajouter un nombre de semaines à une date.
+ 
+### [DChrono.addYears](10-addYears.ts)
+
+Ajouter un nombre d’années à une date en UTC.
+ 
+### [DChrono.applyTimezone](10-applyTimezone.ts)
+
+Décaler une date pour l’exprimer dans un fuseau horaire donné.
+ 
+### [DChrono.betweenThanDate](10-betweenThanDate.ts)
+
+Vérifier qu’une date est strictement comprise entre deux bornes.
+ 
+### [DChrono.betweenThanOrEqualDate](10-betweenThanOrEqualDate.ts)
+
+Vérifier qu’une date est comprise entre deux bornes inclusives.
+ 
+### [DChrono.betweenThanOrEqualTime](10-betweenThanOrEqualTime.ts)
+
+Vérifier qu’une durée est comprise entre deux bornes inclusives.
+ 
+### [DChrono.betweenThanTime](10-betweenThanTime.ts)
+
+Vérifier qu’une durée est strictement comprise entre deux bornes.
+ 
+### [DChrono.closestTo](10-closestTo.ts)
+
+Trouver dans une collection la date la plus proche d’une date cible.
+ 
+### [DChrono.computeTime](10-computeTime.ts)
+
+Convertir une durée représentée par TheTime vers l’unité demandée.
+ 
+### [DChrono.createDate](10-createDate.ts)
+
+Construire une date depuis une valeur sûre ou représenter la validation d’une entrée runtime avec un Either.
+ 
+### [DChrono.createDateOrThrow](10-createDateOrThrow.ts)
+
+Construire une TheDate depuis les entrées acceptées et lever une erreur si la création échoue.
+ 
+### [DChrono.createTime](10-createTime.ts)
+
+Construire une TheTime depuis une durée sûre ou représenter la validation d’une entrée runtime avec un Either.
+ 
+### [DChrono.createTimeOrThrow](10-createTimeOrThrow.ts)
+
+Construire une TheTime depuis les entrées acceptées et lever une erreur si la création échoue.
+ 
+### [DChrono.eachDate](10-eachDate.ts)
+
+Parcourir une plage de dates en avançant d’une unité et en incluant les bornes.
+ 
+### [DChrono.equalDate](10-equalDate.ts)
+
+Vérifier l’égalité de deux dates par leur timestamp.
+ 
+### [DChrono.equalTime](10-equalTime.ts)
+
+Vérifier l’égalité de deux durées par leur valeur en millisecondes.
+ 
+### [DChrono.formatDate](10-formatDate.ts)
+
+Formater une date avec des jetons et un fuseau horaire.
+ 
+### [DChrono.formatTime](10-formatTime.ts)
+
+Formater une durée TheTime avec des jetons de semaines, jours, heures, minutes, secondes et millisecondes.
+ 
+### [DChrono.getDayOfMonth](10-getDayOfMonth.ts)
+
+Lire le jour du mois d’une date en UTC ou dans un fuseau horaire donné.
+ 
+### [DChrono.getDayOfWeek](10-getDayOfWeek.ts)
+
+Lire le jour de la semaine d’une date, de 0 pour dimanche à 6 pour samedi.
+ 
+### [DChrono.getDayOfYear](10-getDayOfYear.ts)
+
+Lire le numéro du jour dans l’année, en tenant compte du fuseau choisi.
+ 
+### [DChrono.getDifference](10-getDifference.ts)
+
+Calculer la durée signée séparant une date d’une date de référence.
+ 
+### [DChrono.getFirstDayOfMonth](10-getFirstDayOfMonth.ts)
+
+Retourner le premier jour du mois à minuit UTC.
+ 
+### [DChrono.getFirstDayOfWeek](10-getFirstDayOfWeek.ts)
+
+Retourner le lundi de la semaine à minuit UTC.
+ 
+### [DChrono.getHour](10-getHour.ts)
+
+Lire l’heure d’une date en UTC ou dans un fuseau horaire donné.
+ 
+### [DChrono.getLastDayOfMonth](10-getLastDayOfMonth.ts)
+
+Retourner le dernier jour du mois à 23:59:59.999 UTC.
+ 
+### [DChrono.getLastDayOfWeek](10-getLastDayOfWeek.ts)
+
+Retourner le dimanche de la semaine à 23:59:59.999 UTC.
+ 
+### [DChrono.getMilliseconds](10-getMilliseconds.ts)
+
+Lire les millisecondes d’une date en UTC.
+ 
+### [DChrono.getMinute](10-getMinute.ts)
+
+Lire les minutes d’une date en UTC ou dans un fuseau horaire donné.
+ 
+### [DChrono.getMonth](10-getMonth.ts)
+
+Lire le mois d’une date, de 1 à 12, en UTC ou dans un fuseau donné.
+ 
+### [DChrono.getSecond](10-getSecond.ts)
+
+Lire les secondes d’une date en UTC ou dans un fuseau horaire donné.
+ 
+### [DChrono.getTimezoneOffset](10-getTimezoneOffset.ts)
+
+Calculer le décalage d’un fuseau horaire pour une date donnée.
+ 
+### [DChrono.getWeekOfYear](10-getWeekOfYear.ts)
+
+Lire le numéro ISO de la semaine d’une date, en tenant compte du fuseau choisi.
+ 
+### [DChrono.getYear](10-getYear.ts)
+
+Lire l’année d’une date en UTC ou dans un fuseau horaire donné.
+ 
+### [DChrono.greaterThanDate](10-greaterThanDate.ts)
+
+Comparer deux dates avec une relation strictement supérieure.
+ 
+### [DChrono.greaterThanOrEqualDate](10-greaterThanOrEqualDate.ts)
+
+Comparer deux dates avec une relation supérieure ou égale.
+ 
+### [DChrono.greaterThanOrEqualTime](10-greaterThanOrEqualTime.ts)
+
+Comparer deux durées avec une relation supérieure ou égale.
+ 
+### [DChrono.greaterThanTime](10-greaterThanTime.ts)
+
+Comparer deux durées avec une relation strictement supérieure.
+ 
+### [DChrono.isDate](10-isDate.ts)
+
+Identifier si une valeur est une instance de TheDate et réduire son type.
+ 
+### [DChrono.isSafeTimeValue](10-isSafeTimeValue.ts)
+
+Vérifier qu’une durée entière reste dans l’intervalle sûr de TheTime.
+ 
+### [DChrono.isSafeTimestamp](10-isSafeTimestamp.ts)
+
+Vérifier qu’un timestamp entier reste dans l’intervalle sûr de TheDate.
+ 
+### [DChrono.isSerializedTheDate](10-isSerializedTheDate.ts)
+
+Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheDate.
+ 
+### [DChrono.isSerializedTheTime](10-isSerializedTheTime.ts)
+
+Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheTime.
+ 
+### [DChrono.isTime](10-isTime.ts)
+
+Identifier si une valeur est une instance de TheTime et réduire son type.
+ 
+### [DChrono.lessThanDate](10-lessThanDate.ts)
+
+Comparer deux dates avec une relation strictement inférieure.
+ 
+### [DChrono.lessThanOrEqualDate](10-lessThanOrEqualDate.ts)
+
+Comparer deux dates avec une relation inférieure ou égale.
+ 
+### [DChrono.lessThanOrEqualTime](10-lessThanOrEqualTime.ts)
+
+Comparer deux durées avec une relation inférieure ou égale.
+ 
+### [DChrono.lessThanTime](10-lessThanTime.ts)
+
+Comparer deux durées avec une relation strictement inférieure.
+ 
+### [DChrono.makeSafeTimeValue](10-makeSafeTimeValue.ts)
+
+Ramener une durée vers un entier compris dans l’intervalle sûr de TheTime.
+ 
+### [DChrono.makeSafeTimestamp](10-makeSafeTimestamp.ts)
+
+Ramener un timestamp vers un entier compris dans l’intervalle sûr de TheDate.
+ 
+### [DChrono.maxDate](10-maxDate.ts)
+
+Retourner la date la plus éloignée dans le futur parmi plusieurs dates.
+ 
+### [DChrono.maxTime](10-maxTime.ts)
+
+Retourner la durée de valeur maximale parmi plusieurs durées.
+ 
+### [DChrono.minDate](10-minDate.ts)
+
+Retourner la date la plus éloignée dans le passé parmi plusieurs dates.
+ 
+### [DChrono.minTime](10-minTime.ts)
+
+Retourner la durée de valeur minimale parmi plusieurs durées.
+ 
+### [DChrono.now](10-now.ts)
+
+Créer une TheDate représentant l’instant courant.
+ 
+### [DChrono.round](10-round.ts)
+
+Ramener une date au début de l’unité UTC demandée.
+ 
+### [DChrono.serialize](10-serialize.ts)
+
+Convertir une TheDate ou une TheTime en chaîne sérialisée.
+ 
+### [DChrono.sortDates](10-sortDates.ts)
+
+Trier des dates par ordre croissant ou décroissant.
+ 
+### [DChrono.sortTimes](10-sortTimes.ts)
+
+Trier des durées par ordre croissant ou décroissant.
+ 
+### [DChrono.subtractDays](10-subtractDays.ts)
+
+Soustraire un nombre de jours à une date.
+ 
+### [DChrono.subtractHours](10-subtractHours.ts)
+
+Soustraire un nombre d’heures à une date.
+ 
+### [DChrono.subtractMilliseconds](10-subtractMilliseconds.ts)
+
+Soustraire un nombre de millisecondes à une date.
+ 
+### [DChrono.subtractMinutes](10-subtractMinutes.ts)
+
+Soustraire un nombre de minutes à une date.
+ 
+### [DChrono.subtractMonths](10-subtractMonths.ts)
+
+Soustraire un nombre de mois à une date en UTC.
+ 
+### [DChrono.subtractSeconds](10-subtractSeconds.ts)
+
+Soustraire un nombre de secondes à une date.
+ 
+### [DChrono.subtractTime](10-subtractTime.ts)
+
+Soustraire une durée à une date ou à une autre durée en conservant la nature de l’entrée.
+ 
+### [DChrono.subtractWeeks](10-subtractWeeks.ts)
+
+Soustraire un nombre de semaines à une date.
+ 
+### [DChrono.subtractYears](10-subtractYears.ts)
+
+Soustraire un nombre d’années à une date en UTC.
+ 
+### [DChrono.toDateISOString](10-toDateISOString.ts)
+
+Convertir une date en chaîne ISO UTC.
+ 
+### [DChrono.toNative](10-toNative.ts)
+
+Convertir une TheDate en Date native ou une TheTime en nombre de millisecondes.
+ 
+### [DChrono.toTimeValue](10-toTimeValue.ts)
+
+Lire la valeur en millisecondes d’une TheTime ou d’une chaîne sérialisée.
+ 
+### [DChrono.toTimestamp](10-toTimestamp.ts)
+
+Lire le timestamp en millisecondes d’une TheDate ou d’une chaîne sérialisée.
+ 
+### [DChrono.today](10-today.ts)
+
+Créer une TheDate correspondant au début du jour courant en UTC.
+ 
+### [DChrono.tomorrow](10-tomorrow.ts)
+
+Créer une TheDate correspondant au début du jour suivant en UTC.
+ 
+### [DChrono.yesterday](10-yesterday.ts)
+
+Créer une TheDate correspondant au début du jour précédent en UTC.
+ 

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

@@ -0,0 +1,3 @@
+## DChrono
+
+Création, calcul, comparaison, sérialisation et formatage des dates, heures, durées et fuseaux horaires dans les représentations Chrono de DuploJS.

package/docs/API/10-lang/10-common/10-and.ts

@@ -0,0 +1,51 @@
+/**
+ * @title DCommon.and
+ *
+ * Combiner plusieurs prédicats dans une condition qui doit tous les satisfaire.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+// Appel classique : les deux predicates doivent accepter la valeur.
+const result = DCommon.and("duplojs", [
+	DCommon.isType("string"),
+	DCommon.truthy,
+]);
+
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const source: string | number;
+
+if (DCommon.and(source, [DCommon.isType("string"), DCommon.truthy])) {
+	type _CheckIfValue = DCommon.ExpectType<typeof source, string, "strict">;
+	const uppercase = DString.toUpperCase(source);
+	type _CheckUppercase = DCommon.ExpectType<typeof uppercase, Uppercase<string>, "strict">;
+}
+
+// Appel curifié : le predicate composé est passé directement à DCommon.when.
+const transformed = DCommon.pipe(
+	source,
+	DCommon.when(
+		DCommon.and([
+			DCommon.isType("string"),
+			DCommon.truthy,
+		]),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<
+				typeof value,
+				string,
+				"strict"
+			>;
+
+			return DString.toUpperCase(value);
+		},
+	),
+);
+
+// La sortie est la source en majuscules si elle est une chaîne non vide, sinon la source inchangée.
+type _CheckTransformed = DCommon.ExpectType<
+	typeof transformed,
+	number | Uppercase<string>,
+	"strict"
+>;

package/docs/API/10-lang/10-common/10-asserts.ts

@@ -0,0 +1,13 @@
+/**
+ * @title DCommon.asserts
+ *
+ * Affirmer une contrainte de type et lever une erreur si le prédicat échoue.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+declare const input: string | number;
+
+DCommon.asserts(input, DCommon.isType("string"));
+
+// Après l’assertion, input est garanti comme une chaîne.
+type _CheckInput = DCommon.ExpectType<typeof input, string, "strict">;

package/docs/API/10-lang/10-common/10-asyncInnerPipe.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DCommon.asyncInnerPipe
+ *
+ * Construire une fonction qui enchaîne des opérations synchrones ou asynchrones.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+import * as DString from "@duplojs/lang/string";
+
+const result = DCommon.asyncPipe(
+	"value",
+	DCommon.asyncInnerPipe(
+		DString.toUpperCase,
+		DString.length,
+	),
+);
+
+// La fonction composée retourne la longueur positive dans une Promise.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Promise<number & DNumber.Positive>,
+	"strict"
+>;

package/docs/API/10-lang/10-common/10-asyncLoop.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DCommon.asyncLoop
+ *
+ * Répéter une callback asynchrone jusqu’à `exit`, avec un compteur et une valeur de retour typée.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+const result = DCommon.asyncLoop<"done">(async({
+	count,
+	next,
+	exit,
+}) => {
+	await DCommon.timeout();
+
+	if (count === 3) {
+		return exit("done");
+	}
+
+	return next();
+});
+
+// La callback est attendue à chaque tour. `next` ne transmet pas d’état à l’itération suivante.
+type _CheckResult = DCommon.ExpectType<typeof result, Promise<"done">, "strict">;