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

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,45 @@
+/**
+ * @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;
+
+// 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,25 @@
+/**
+ * @title DCommon.asyncLoop
+ *
+ * Contrôler une boucle asynchrone avec un compteur et une sortie typée.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+const result = DCommon.asyncLoop<"done", number>(async({
+	count,
+	previousOutput,
+	next,
+	exit,
+}) => {
+	const current = previousOutput ?? 0;
+	await DCommon.timeout();
+
+	if (count === 3) {
+		return exit("done");
+	}
+
+	return next(current + 1);
+});
+
+// La callback est attendue asynchrone, mais conserve les mêmes paramètres que `loop`.
+type _CheckResult = DCommon.ExpectType<typeof result, Promise<"done">, "strict">;

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

@@ -0,0 +1,21 @@
+/**
+ * @title DCommon.asyncPipe
+ *
+ * Exécuter séquentiellement plusieurs transformations en attendant chaque résultat.
+ */
+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",
+	DString.toUpperCase,
+	DString.length,
+);
+
+// Le résultat final est la longueur positive de la chaîne transformée.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	Promise<number & DNumber.Positive>,
+	"strict"
+>;

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

@@ -0,0 +1,22 @@
+/**
+ * @title DCommon.callThen
+ *
+ * Appliquer une fonction à une valeur immédiate ou promise, avec gestion optionnelle des erreurs.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DString from "@duplojs/lang/string";
+
+const result = DCommon.callThen("value", DString.toUpperCase);
+
+// Une valeur immédiate reste immédiate après l’application de la fonction.
+type _CheckResult = DCommon.ExpectType<typeof result, Uppercase<string>, "strict">;
+
+declare const promisedValue: Promise<string>;
+const promisedResult = DCommon.callThen(promisedValue, DString.toUpperCase);
+
+// Une Promise conserve son caractère asynchrone.
+type _CheckPromisedResult = DCommon.ExpectType<
+	typeof promisedResult,
+	Promise<Uppercase<string>>,
+	"strict"
+>;

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

@@ -0,0 +1,16 @@
+/**
+ * @title DCommon.cast
+ *
+ * Vérifier au niveau du typage qu’une valeur respecte une contrainte attendue.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import type * as DString from "@duplojs/lang/string";
+
+const result: string & DString.MinCharacters<10> = DCommon.cast("thisIsASuperName");
+
+// La compatibilité est vérifiée par TypeScript ; cast n’ajoute aucune validation runtime.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	string & DString.MinCharacters<10>,
+	"strict"
+>;

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

@@ -0,0 +1,12 @@
+/**
+ * @title DCommon.clone
+ *
+ * Copier récursivement les tableaux et objets simples sans modifier la valeur source.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+const source = { nested: { value: 1 } };
+const result = DCommon.clone(source);
+
+// La copie conserve la forme typée de l’objet source.
+type _CheckResult = DCommon.ExpectType<typeof result, typeof source, "strict">;

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

@@ -0,0 +1,34 @@
+/**
+ * @title DCommon.createAsyncRetry
+ *
+ * Décorer une fonction asynchrone avec une stratégie de nouvelle tentative.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+let callCount = 0;
+
+const retry = DCommon.createAsyncRetry(
+	async(value: string) => {
+		callCount += 1;
+		await DCommon.timeout();
+
+		return callCount === 1 ? "retry" : value;
+	},
+	DCommon.equal("retry"),
+	{
+		maxRetry: 3,
+		timeToSleep: 10,
+	},
+);
+const result = retry("done");
+
+// La fonction décorée conserve ses paramètres et retourne une Promise.
+type _CheckRetry = DCommon.ExpectType<
+	typeof retry,
+	(value: string) => Promise<string>,
+	"strict"
+>;
+type _CheckResult = DCommon.ExpectType<typeof result, Promise<string>, "strict">;
+
+// Le prédicat vrai (`result === "retry"`) relance l’opération ; `done` arrête les tentatives.
+// `maxRetry` limite le nombre d’essais et `timeToSleep` règle la pause entre deux essais.

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

@@ -0,0 +1,19 @@
+/**
+ * @title DCommon.createBuilder
+ *
+ * Configurer des handlers réutilisables pour construire un objet par étapes.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+interface ExampleBuilder extends DCommon.Builder<{ value: string }> {
+	build(): { value: string };
+}
+
+const handlers = DCommon.createBuilder<ExampleBuilder>("api-documentation-builder").set(
+	"build",
+	({ accumulator }) => accumulator,
+);
+const result = handlers.use({ value: "done" }).build();
+
+// Le handler réutilise l’accumulateur et conserve sa forme typée.
+type _CheckResult = DCommon.ExpectType<typeof result, { value: string }, "strict">;

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

@@ -0,0 +1,25 @@
+/**
+ * @title DCommon.createEnum
+ *
+ * Créer un enum littéral qui expose ses valeurs, un tuple et un prédicat `has`.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+const status = DCommon.createEnum([
+	"pending",
+	"done",
+]);
+const result = status.toTuple();
+
+// Le tuple conserve les valeurs littérales et leur ordre.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	readonly ["pending", "done"],
+	"strict"
+>;
+
+declare const input: "pending" | "done" | "missing";
+if (status.has(input)) {
+	// Le predicate has affine l’union vers les valeurs de l’enum.
+	type _CheckInput = DCommon.ExpectType<typeof input, "pending" | "done", "strict">;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @title DCommon.createExternalPromise
+ *
+ * Exposer les contrôles `resolve` et `reject` d’une promise séparément de sa création.
+ */
+import * as DCommon from "@duplojs/lang/common";
+
+const external = DCommon.createExternalPromise<string>();
+const result = external.promise;
+
+// La promise est résolue séparément par la méthode resolve.
+external.resolve("done");
+type _CheckResult = DCommon.ExpectType<typeof result, Promise<string>, "strict">;