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

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

@@ -0,0 +1,45 @@
+/**
+ * @title DChrono.closestTo
+ *
+ * Trouver dans une collection la date la plus proche d’une date cible.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const dates: readonly [DChrono.TheDate, DChrono.TheDate];
+const target = DChrono.createDate("2021-01-15");
+
+const closest = DChrono.closestTo(dates, target);
+
+// La sortie est la date la plus proche ; en cas d’égalité, la première date retenue est conservée.
+type _CheckClosest = DCommon.ExpectType<typeof closest, DChrono.TheDate | undefined, "strict">;
+
+// Le paramètre favorPast impose de retenir une date antérieure lorsque c’est possible.
+const pastClosest = DChrono.closestTo(dates, target, { tieBreaker: "favorPast" });
+type _CheckPastClosest = DCommon.ExpectType<typeof pastClosest, DChrono.TheDate | undefined, "strict">;
+
+// La valeur favorFuture retient l’antérieure ou l’ultérieure selon la stratégie demandée.
+const futureClosest = DChrono.closestTo(dates, target, { tieBreaker: "favorFuture" });
+type _CheckFutureClosest = DCommon.ExpectType<typeof futureClosest, DChrono.TheDate | undefined, "strict">;
+
+// La forme curifiée s’utilise comme étape de pipe sur la collection.
+const piped = DCommon.pipe(
+	dates,
+	DChrono.closestTo(target),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate | undefined, "strict">;
+
+// Les collections peuvent mélanger TheDate et dates sérialisées.
+declare const mixedDates: readonly [
+	DChrono.TheDate | DChrono.SerializedTheDate,
+	DChrono.TheDate | DChrono.SerializedTheDate,
+];
+const mixedClosest = DChrono.closestTo(
+	mixedDates,
+	"date1609804800000+",
+	{ tieBreaker: "favorFuture" },
+);
+
+// La sortie reste une TheDate éventuellement absente, avec le tie-breaker favorFuture.
+type _CheckMixed = DCommon.ExpectType<typeof mixedClosest, DChrono.TheDate | undefined, "strict">;
+

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

@@ -0,0 +1,35 @@
+/**
+ * @title DChrono.computeTime
+ *
+ * Convertir une durée représentée par TheTime vers l’unité demandée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(90_061);
+const inSeconds = DChrono.computeTime(time, "second");
+
+// La valeur obtenue est 90.061.
+type _CheckSeconds = DCommon.ExpectType<typeof inSeconds, number, "strict">;
+
+// La forme curifiée fixe l’unité dans le pipe.
+const inMinutes = DCommon.pipe(
+	time,
+	DChrono.computeTime("minute"),
+);
+
+// La sortie représente la durée exprimée en minutes.
+type _CheckMinutes = DCommon.ExpectType<typeof inMinutes, number, "strict">;
+
+// Les six unités acceptées produisent toujours un nombre exprimé dans l’unité choisie.
+const inWeeks = DChrono.computeTime(time, "week");
+const inDays = DChrono.computeTime(time, "day");
+const inHours = DChrono.computeTime(time, "hour");
+const inMilliseconds = DChrono.computeTime(time, "millisecond");
+
+type _CheckUnits = DCommon.ExpectType<
+	[typeof inWeeks, typeof inDays, typeof inHours, typeof inMinutes, typeof inSeconds, typeof inMilliseconds],
+	[number, number, number, number, number, number],
+	"strict"
+>;
+

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

@@ -0,0 +1,122 @@
+/**
+ * @title DChrono.createDate
+ *
+ * Construire une date depuis une valeur sûre ou représenter la validation d’une entrée runtime avec un Either.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+// Une chaîne de date sûre est vérifiée par le typage et produit directement une TheDate.
+const safeDate = DChrono.createDate("2021-01-15");
+
+// La valeur obtenue représente le 15 janvier 2021 à minuit UTC.
+type _CheckSafeDate = DCommon.ExpectType<typeof safeDate, DChrono.TheDate, "strict">;
+
+// Les paramètres horaires complètent une chaîne de date sûre.
+const safeDateWithTime = DChrono.createDate("2024-06-05", {
+	hour: "23",
+	minute: "59",
+	second: "59",
+	millisecond: "999",
+});
+
+// La valeur obtenue représente le 5 juin 2024 à 23:59:59.999 UTC.
+type _CheckSafeDateWithTime = DCommon.ExpectType<typeof safeDateWithTime, DChrono.TheDate, "strict">;
+
+// Les années bissextiles sont aussi vérifiées lorsque la date est un littéral.
+const leapDay = DChrono.createDate("2024-02-29");
+type _CheckLeapDay = DCommon.ExpectType<typeof leapDay, DChrono.TheDate, "strict">;
+
+// @ts-expect-error Une date littérale doit respecter le calendrier grégorien.
+DChrono.createDate("2023-02-29");
+
+// Une TheDate existante peut être réutilisée comme entrée ; sa sortie reste un Either.
+const fromTheDate = DChrono.createDate(safeDate);
+
+// Un timestamp produit un Right si sa valeur est dans l’intervalle sûr.
+const fromTimestamp = DChrono.createDate(1_609_459_200_000);
+
+// Une Date native valide est également convertie vers un Right.
+const fromNativeDate = DChrono.createDate(new Date("2021-01-01T00:00:00.000Z"));
+
+// Une chaîne sérialisée accepte le format produit par DChrono.serialize.
+const fromSerializedDate = DChrono.createDate("date1609459200000+");
+
+// Ces quatre formes runtime ont toutes le contrat MayBeDate : Right contient la TheDate, Left signale le refus.
+type _CheckRuntimeInputs = DCommon.ExpectType<
+	[typeof fromTheDate, typeof fromTimestamp, typeof fromNativeDate, typeof fromSerializedDate],
+	[DChrono.MayBeDate, DChrono.MayBeDate, DChrono.MayBeDate, DChrono.MayBeDate],
+	"strict"
+>;
+
+if (DEither.isRight(fromTimestamp)) {
+	const serialized = DChrono.serialize(DEither.unwrapRight(fromTimestamp));
+
+	// La sortie est « date1609459200000+ » pour ce timestamp.
+	type _CheckSerialized = DCommon.ExpectType<typeof serialized, DChrono.SerializedTheDate, "strict">;
+}
+
+// Un objet SpoolingDate peut partir d’un ISO, d’un timestamp, d’une Date native,
+// d’une chaîne sérialisée ou d’une TheDate.
+const fromIsoObject = DChrono.createDate({
+	value: "2021-01-01T00:00:00.000Z",
+});
+const fromTimestampObject = DChrono.createDate({ value: 1_609_459_200_000 });
+const fromNativeDateObject = DChrono.createDate({
+	value: new Date("2021-01-01T00:00:00.000Z"),
+});
+const fromSerializedObject = DChrono.createDate({ value: "date1609459200000+" });
+const fromTheDateObject = DChrono.createDate({ value: safeDate });
+
+// Chaque objet produit un Either, car sa valeur et ses options sont vérifiées au runtime.
+type _CheckSpoolingValues = DCommon.ExpectType<
+	[
+		typeof fromIsoObject,
+		typeof fromTimestampObject,
+		typeof fromNativeDateObject,
+		typeof fromSerializedObject,
+		typeof fromTheDateObject,
+	],
+	[
+		DChrono.MayBeDate,
+		DChrono.MayBeDate,
+		DChrono.MayBeDate,
+		DChrono.MayBeDate,
+		DChrono.MayBeDate,
+	],
+	"strict"
+>;
+
+// Les propriétés de SpoolingDate peuvent remplacer chaque composante de la valeur de départ.
+const withOverrides = DChrono.createDate({
+	value: new Date("2020-01-01T00:00:00.000Z"),
+	year: 2022,
+	month: 1,
+	day: 2,
+	hour: 3,
+	minute: 4,
+	second: 5,
+	millisecond: 6,
+});
+
+// La sortie est un Right si les remplacements restent dans l’intervalle des dates sûres.
+type _CheckOverrides = DCommon.ExpectType<typeof withOverrides, DChrono.MayBeDate, "strict">;
+
+// Un fuseau horaire applique ensuite son décalage à la date reconstruite.
+const withTimezone = DChrono.createDate({
+	value: "2024-01-01T00:00:00.000Z",
+	timezone: "America/New_York",
+});
+
+// Une timezone invalide ou une entrée non reconnue produit un Left au lieu d’une date.
+const invalid = DChrono.createDate(new Date(Number.NaN));
+type _CheckTimezone = DCommon.ExpectType<typeof withTimezone, DChrono.MayBeDate, "strict">;
+type _CheckInvalid = DCommon.ExpectType<typeof invalid, DChrono.MayBeDate, "strict">;
+
+if (DEither.isLeft(invalid)) {
+	// La valeur obtenue est Left<"date-created-error", null>.
+	const errorValue = DEither.unwrapLeft(invalid);
+	type _CheckError = DCommon.ExpectType<typeof errorValue, null, "strict">;
+}
+

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

@@ -0,0 +1,39 @@
+/**
+ * @title DChrono.createDateOrThrow
+ *
+ * Construire une TheDate depuis les entrées acceptées et lever une erreur si la création échoue.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+
+// Une TheDate existante est renvoyée sous forme de TheDate.
+const fromTheDate = DChrono.createDateOrThrow(date);
+
+// Les formes timestamp, Date native et date sérialisée sont également acceptées.
+const fromTimestamp = DChrono.createDateOrThrow(1_609_459_200_000);
+const fromNativeDate = DChrono.createDateOrThrow(new Date("2021-01-01T00:00:00.000Z"));
+const fromSerialized = DChrono.createDateOrThrow("date1609459200000+");
+
+// Un objet SpoolingDate permet de fournir une valeur et des remplacements de composantes.
+const fromSpoolingDate = DChrono.createDateOrThrow({
+	value: "2021-01-01T00:00:00.000Z",
+	hour: 12,
+	minute: 34,
+});
+
+// Toutes les formes valides produisent directement une TheDate.
+type _CheckInputs = DCommon.ExpectType<
+	[
+		typeof fromTheDate,
+		typeof fromTimestamp,
+		typeof fromNativeDate,
+		typeof fromSerialized,
+		typeof fromSpoolingDate,
+	],
+	[DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate],
+	"strict"
+>;
+
+// Une entrée invalide lève CreateTheDateError au lieu de produire un Either.

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

@@ -0,0 +1,86 @@
+/**
+ * @title DChrono.createTime
+ *
+ * Construire une TheTime depuis une durée sûre ou représenter la validation d’une entrée runtime avec un Either.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DEither from "@duplojs/lang/either";
+import type * as DCommon from "@duplojs/lang/common";
+
+// Une valeur accompagnée d’une unité produit directement une TheTime.
+const safeTime = DChrono.createTime(2, "hour");
+
+// La valeur obtenue représente deux heures en millisecondes.
+type _CheckSafeTime = DCommon.ExpectType<typeof safeTime, DChrono.TheTime, "strict">;
+
+// Chaque unité publique peut être utilisée avec cette forme d’appel.
+const byWeek = DChrono.createTime(1, "week");
+const byDay = DChrono.createTime(1, "day");
+const byHour = DChrono.createTime(1, "hour");
+const byMinute = DChrono.createTime(1, "minute");
+const bySecond = DChrono.createTime(1, "second");
+const byMillisecond = DChrono.createTime(1, "millisecond");
+
+// Chaque sortie est une TheTime ; l’unité choisit la conversion en millisecondes.
+type _CheckUnits = DCommon.ExpectType<
+	[typeof byWeek, typeof byDay, typeof byHour, typeof byMinute, typeof bySecond, typeof byMillisecond],
+	[DChrono.TheTime, DChrono.TheTime, DChrono.TheTime, DChrono.TheTime, DChrono.TheTime, DChrono.TheTime],
+	"strict"
+>;
+
+// Sans unité, un nombre représente directement des millisecondes et sa validité est vérifiée au runtime.
+const fromMilliseconds = DChrono.createTime(90_000);
+
+// Une chaîne sérialisée est également validée au runtime.
+const fromSerialized = DChrono.createTime("time90000+");
+
+// Une TheTime existante passe par la forme d’entrée runtime.
+const fromTheTime = DChrono.createTime(safeTime);
+
+type _CheckRuntimeInputs = DCommon.ExpectType<
+	[typeof fromMilliseconds, typeof fromSerialized, typeof fromTheTime],
+	[DChrono.MayBeTime, DChrono.MayBeTime, DChrono.MayBeTime],
+	"strict"
+>;
+
+if (DEither.isRight(fromMilliseconds)) {
+	const serialized = DChrono.serialize(DEither.unwrapRight(fromMilliseconds));
+
+	// La sortie représente la durée validée sous forme de SerializedTheTime.
+	type _CheckSerialized = DCommon.ExpectType<typeof serialized, DChrono.SerializedTheTime, "strict">;
+}
+
+// Un objet SpoolingTime peut combiner une valeur de départ et des décalages dans toutes les unités.
+const fromSpoolingObject = DChrono.createTime({
+	value: "01:02:03.004Z",
+	week: 1,
+	day: 2,
+	hour: 3,
+	minute: 4,
+	second: 5,
+	millisecond: 6,
+});
+
+// L’objet produit un Either : Right contient la durée reconstruite, Left signale une entrée invalide.
+type _CheckSpoolingObject = DCommon.ExpectType<typeof fromSpoolingObject, DChrono.MayBeTime, "strict">;
+
+// Les trois valeurs acceptées par SpoolingTime peuvent aussi être utilisées séparément.
+const fromNumberObject = DChrono.createTime({ value: 2_500 });
+const fromSerializedObject = DChrono.createTime({ value: "time2500+" });
+const fromTheTimeObject = DChrono.createTime({ value: safeTime });
+
+type _CheckSpoolingValues = DCommon.ExpectType<
+	[typeof fromNumberObject, typeof fromSerializedObject, typeof fromTheTimeObject],
+	[DChrono.MayBeTime, DChrono.MayBeTime, DChrono.MayBeTime],
+	"strict"
+>;
+
+// Une valeur qui dépasse l’intervalle sûr devient un Left plutôt qu’une TheTime invalide.
+const invalid = DChrono.createTime(Number.MAX_SAFE_INTEGER + 1);
+type _CheckInvalid = DCommon.ExpectType<typeof invalid, DChrono.MayBeTime, "strict">;
+
+if (DEither.isLeft(invalid)) {
+	// La valeur obtenue est Left<"time-created-error", null>.
+	const errorValue = DEither.unwrapLeft(invalid);
+	type _CheckError = DCommon.ExpectType<typeof errorValue, null, "strict">;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * @title DChrono.createTimeOrThrow
+ *
+ * Construire une TheTime depuis les entrées acceptées et lever une erreur si la création échoue.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(90_000);
+
+// Une TheTime existante peut être réutilisée.
+const fromTheTime = DChrono.createTimeOrThrow(time);
+
+// Les formes sérialisée et SpoolingTime sont également acceptées.
+const fromSerialized = DChrono.createTimeOrThrow("time90000+");
+const fromSpoolingTime = DChrono.createTimeOrThrow({
+	value: 60_000,
+	second: 30,
+});
+
+// Toutes les formes valides produisent directement une TheTime.
+type _CheckInputs = DCommon.ExpectType<
+	[typeof time, typeof fromTheTime, typeof fromSerialized, typeof fromSpoolingTime],
+	[DChrono.TheTime, DChrono.TheTime, DChrono.TheTime, DChrono.TheTime],
+	"strict"
+>;
+
+// Une entrée invalide lève CreateTheTimeError au lieu de produire un Either.

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

@@ -0,0 +1,67 @@
+/**
+ * @title DChrono.eachDate
+ *
+ * Parcourir une plage de dates en avançant d’une unité et en incluant les bornes.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const dates = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-03"),
+}));
+
+// La collection contient les dates du 1er au 3 janvier, avec un pas quotidien par défaut.
+type _CheckDates = DCommon.ExpectType<typeof dates, readonly DChrono.TheDate[], "strict">;
+
+const months = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-03-01"),
+}, "month"));
+
+// Une unité explicite modifie le pas de parcours.
+type _CheckMonths = DCommon.ExpectType<typeof months, readonly DChrono.TheDate[], "strict">;
+
+// Tous les pas d’Unit peuvent être choisis pour une plage alignée.
+const byHour = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-01"),
+}, "hour"));
+const byMinute = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-01"),
+}, "minute"));
+const bySecond = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-01"),
+}, "second"));
+const byMillisecond = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-01"),
+}, "millisecond"));
+const byYear = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-01"),
+	end: DChrono.createDate("2021-01-01"),
+}, "year"));
+
+// Chaque parcours produit une collection de TheDate ; le pas change la progression entre les bornes.
+type _CheckUnits = DCommon.ExpectType<
+	[typeof byHour, typeof byMinute, typeof bySecond, typeof byMillisecond, typeof byYear],
+	[
+		readonly DChrono.TheDate[],
+		readonly DChrono.TheDate[],
+		readonly DChrono.TheDate[],
+		readonly DChrono.TheDate[],
+		readonly DChrono.TheDate[],
+	],
+	"strict"
+>;
+
+// Une borne de fin antérieure déclenche un parcours décroissant.
+const descending = DArray.from(DChrono.eachDate({
+	start: DChrono.createDate("2021-01-03"),
+	end: DChrono.createDate("2021-01-01"),
+}));
+type _CheckDescending = DCommon.ExpectType<typeof descending, readonly DChrono.TheDate[], "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.equalDate
+ *
+ * Vérifier l’égalité de deux dates par leur timestamp.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const threshold = DChrono.createDate("2021-01-15");
+const result = DChrono.equalDate(date, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.equalDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.equalDate("date1609459200000+", "date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.equalTime
+ *
+ * Vérifier l’égalité de deux durées par leur valeur en millisecondes.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(2_000);
+const threshold = DChrono.createTimeOrThrow(2_000);
+const result = DChrono.equalTime(time, threshold);
+
+// La comparaison produit true pour ces deux valeurs.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// La forme curifiée fixe la seconde valeur dans le pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.equalTime(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.equalTime("time2000+", "time2000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,43 @@
+/**
+ * @title DChrono.formatDate
+ *
+ * Formater une date avec des jetons et un fuseau horaire.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const formatted = DChrono.formatDate(
+	date,
+	"YYYY-MM-DD HH:mm:ss ZZ",
+	"UTC",
+);
+
+// La sortie est une chaîne où chaque jeton est remplacé par la partie correspondante de la date.
+type _CheckFormatted = DCommon.ExpectType<typeof formatted, string, "strict">;
+
+// La forme curifiée fixe le format et le fuseau dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.formatDate("YYYY/MM/DD", "UTC"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;
+
+// Les jetons YYYY, YY, MM, DD, HH, mm, ss, SSS et ZZ peuvent être combinés.
+const allTokens = DChrono.formatDate(
+	date,
+	"YYYY YY MM DD HH mm ss SSS ZZ",
+	"Europe/Paris",
+);
+
+// La sortie reste une chaîne, avec chaque jeton remplacé par la composante demandée.
+type _CheckAllTokens = DCommon.ExpectType<typeof allTokens, string, "strict">;
+
+// Une date sérialisée est acceptée par la même surcharge que TheDate.
+const serializedDate = DChrono.formatDate(
+	"date1609459200000+",
+	"YYYY-MM-DD",
+	"UTC",
+);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedDate, string, "strict">;
+

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

@@ -0,0 +1,37 @@
+/**
+ * @title DChrono.formatTime
+ *
+ * Formater une durée TheTime avec des jetons de semaines, jours, heures, minutes, secondes et millisecondes.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(90_061);
+const formatted = DChrono.formatTime(time, "HH:mm:ss.SSS");
+
+// La sortie est une chaîne construite à partir de la durée.
+type _CheckFormatted = DCommon.ExpectType<typeof formatted, string, "strict">;
+
+// La forme curifiée fixe le format dans l’étape de pipe.
+const piped = DCommon.pipe(
+	time,
+	DChrono.formatTime("DD HH:mm:ss"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;
+
+// Les jetons WW, DD, HH, mm, ss et SSS peuvent être combinés.
+const allTokens = DChrono.formatTime(
+	time,
+	"WW DD HH mm ss SSS",
+);
+
+// La sortie représente la durée avec chacune des composantes demandées.
+type _CheckAllTokens = DCommon.ExpectType<typeof allTokens, string, "strict">;
+
+// Une durée sérialisée est acceptée directement.
+const serializedTime = DChrono.formatTime(
+	"time90061+",
+	"HH:mm:ss.SSS",
+);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedTime, string, "strict">;
+

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

@@ -0,0 +1,37 @@
+/**
+ * @title DChrono.getDayOfMonth
+ *
+ * Lire le jour du mois d’une date en UTC ou dans un fuseau horaire donné.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+// Appel classique : le fuseau UTC est utilisé par défaut.
+const utcDay = DChrono.getDayOfMonth(
+	DChrono.createDate("2021-01-15"),
+);
+
+// La valeur obtenue est 15.
+type _CheckUtcDay = DCommon.ExpectType<typeof utcDay, number, "strict">;
+
+// Variation de fuseau horaire : le jour est calculé dans le fuseau demandé.
+const newYorkDay = DChrono.getDayOfMonth(
+	DChrono.createDate("2021-01-01"),
+	"America/New_York",
+);
+
+// La valeur obtenue est 31, car minuit UTC correspond encore au 31 décembre à New York.
+type _CheckNewYorkDay = DCommon.ExpectType<typeof newYorkDay, number, "strict">;
+
+// Composition dans un pipe : la fonction peut être utilisée directement comme étape unaire.
+const pipedDay = DCommon.pipe(
+	DChrono.createDate("2021-12-25"),
+	DChrono.getDayOfMonth,
+);
+
+// La valeur obtenue est 25.
+type _CheckPipedDay = DCommon.ExpectType<typeof pipedDay, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serializedDay = DChrono.getDayOfMonth("date1609459200000+");
+type _CheckSerializedDay = DCommon.ExpectType<typeof serializedDay, number, "strict">;

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

@@ -0,0 +1,30 @@
+/**
+ * @title DChrono.getDayOfWeek
+ *
+ * Lire le jour de la semaine d’une date, de 0 pour dimanche à 6 pour samedi.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDateOrThrow({
+	value: "2021-01-15",
+	hour: 12,
+	minute: 34,
+	second: 56,
+	millisecond: 789,
+});
+const day = DChrono.getDayOfWeek(date);
+
+// La valeur obtenue est 5 pour le vendredi 15 janvier 2021.
+type _CheckDay = DCommon.ExpectType<typeof day, number, "strict">;
+
+const piped = DCommon.pipe(
+	date,
+	DChrono.getDayOfWeek,
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;
+
+// Une date sérialisée conserve le même calcul du jour de la semaine.
+const serialized = DChrono.getDayOfWeek("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,28 @@
+/**
+ * @title DChrono.getDayOfYear
+ *
+ * Lire le numéro du jour dans l’année, en tenant compte du fuseau choisi.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDateOrThrow({
+	value: "2021-01-15",
+	hour: 12,
+	minute: 34,
+	second: 56,
+	millisecond: 789,
+});
+const day = DChrono.getDayOfYear(date);
+
+// La valeur obtenue est 15.
+type _CheckDay = DCommon.ExpectType<typeof day, number, "strict">;
+
+// Un fuseau explicite peut faire basculer la date vers un autre jour de l’année.
+const inNewYork = DChrono.getDayOfYear(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// La surcharge accepte aussi une date sérialisée.
+const serialized = DChrono.getDayOfYear("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+