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

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

@@ -0,0 +1,29 @@
+/**
+ * @title DChrono.getDifference
+ *
+ * Calculer la durée signée séparant une date d’une date de référence.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const reference = DChrono.createDate("2021-01-01");
+const date = DChrono.createDate("2021-01-02");
+const difference = DChrono.getDifference(date, reference);
+
+// La valeur obtenue est une TheTime positive représentant un jour.
+type _CheckDifference = DCommon.ExpectType<typeof difference, DChrono.TheTime, "strict">;
+
+// La forme curifiée fixe la référence dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.getDifference(reference),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheTime, "strict">;
+
+// Les deux dates peuvent aussi être fournies sous forme sérialisée.
+const serializedDifference = DChrono.getDifference(
+	"date1609545600000+",
+	"date1609459200000+",
+);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedDifference, DChrono.TheTime, "strict">;
+

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

@@ -0,0 +1,24 @@
+/**
+ * @title DChrono.getFirstDayOfMonth
+ *
+ * Retourner le premier jour du mois à minuit UTC.
+ */
+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 first = DChrono.getFirstDayOfMonth(date);
+
+// La sortie représente le 1er janvier 2021 à 00:00:00.000 UTC.
+type _CheckFirst = DCommon.ExpectType<typeof first, DChrono.TheDate, "strict">;
+
+// Une date sérialisée peut être utilisée comme entrée.
+const serializedFirst = DChrono.getFirstDayOfMonth("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedFirst, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,24 @@
+/**
+ * @title DChrono.getFirstDayOfWeek
+ *
+ * Retourner le lundi de la semaine à minuit UTC.
+ */
+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 first = DChrono.getFirstDayOfWeek(date);
+
+// La sortie représente le lundi 11 janvier 2021 à 00:00:00.000 UTC.
+type _CheckFirst = DCommon.ExpectType<typeof first, DChrono.TheDate, "strict">;
+
+// Une date sérialisée peut être utilisée comme entrée.
+const serializedFirst = DChrono.getFirstDayOfWeek("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedFirst, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,28 @@
+/**
+ * @title DChrono.getHour
+ *
+ * Lire l’heure d’une date en UTC ou dans un fuseau horaire donné.
+ */
+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 hour = DChrono.getHour(date);
+
+// La valeur obtenue est 12 en UTC.
+type _CheckHour = DCommon.ExpectType<typeof hour, number, "strict">;
+
+const inNewYork = DChrono.getHour(date, "America/New_York");
+// Le résultat représente l’heure locale dans le fuseau demandé.
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée, avec ou sans fuseau explicite.
+const serialized = DChrono.getHour("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,24 @@
+/**
+ * @title DChrono.getLastDayOfMonth
+ *
+ * Retourner le dernier jour du mois à 23:59:59.999 UTC.
+ */
+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 last = DChrono.getLastDayOfMonth(date);
+
+// La sortie représente le 31 janvier 2021 à 23:59:59.999 UTC.
+type _CheckLast = DCommon.ExpectType<typeof last, DChrono.TheDate, "strict">;
+
+// Une date sérialisée peut être utilisée comme entrée.
+const serializedLast = DChrono.getLastDayOfMonth("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedLast, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,24 @@
+/**
+ * @title DChrono.getLastDayOfWeek
+ *
+ * Retourner le dimanche de la semaine à 23:59:59.999 UTC.
+ */
+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 last = DChrono.getLastDayOfWeek(date);
+
+// La sortie représente le dimanche 17 janvier 2021 à 23:59:59.999 UTC.
+type _CheckLast = DCommon.ExpectType<typeof last, DChrono.TheDate, "strict">;
+
+// Une date sérialisée peut être utilisée comme entrée.
+const serializedLast = DChrono.getLastDayOfWeek("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedLast, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,24 @@
+/**
+ * @title DChrono.getMilliseconds
+ *
+ * Lire les millisecondes d’une date en UTC.
+ */
+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 milliseconds = DChrono.getMilliseconds(date);
+
+// La valeur obtenue est 789.
+type _CheckMilliseconds = DCommon.ExpectType<typeof milliseconds, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getMilliseconds("date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.getMinute
+ *
+ * Lire les minutes d’une date en UTC ou dans un fuseau horaire donné.
+ */
+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 minute = DChrono.getMinute(date);
+
+// La valeur obtenue est 34 en UTC.
+type _CheckMinute = DCommon.ExpectType<typeof minute, number, "strict">;
+
+const inNewYork = DChrono.getMinute(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getMinute("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.getMonth
+ *
+ * Lire le mois d’une date, de 1 à 12, en UTC ou dans un fuseau donné.
+ */
+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 month = DChrono.getMonth(date);
+
+// La valeur obtenue est 1.
+type _CheckMonth = DCommon.ExpectType<typeof month, number, "strict">;
+
+const inNewYork = DChrono.getMonth(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getMonth("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.getSecond
+ *
+ * Lire les secondes d’une date en UTC ou dans un fuseau horaire donné.
+ */
+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 second = DChrono.getSecond(date);
+
+// La valeur obtenue est 56 en UTC.
+type _CheckSecond = DCommon.ExpectType<typeof second, number, "strict">;
+
+const inNewYork = DChrono.getSecond(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getSecond("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,28 @@
+/**
+ * @title DChrono.getTimezoneOffset
+ *
+ * Calculer le décalage d’un fuseau horaire pour une date donnée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-15");
+const offset = DChrono.getTimezoneOffset(date, "America/New_York");
+
+// La sortie est un décalage en millisecondes, dépendant de la date et du fuseau.
+type _CheckOffset = DCommon.ExpectType<typeof offset, number, "strict">;
+
+// La forme curifiée fixe le fuseau dans le pipe.
+const piped = DCommon.pipe(
+	date,
+	DChrono.getTimezoneOffset("UTC"),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;
+
+// Une date sérialisée accepte les mêmes fuseaux horaires.
+const serializedOffset = DChrono.getTimezoneOffset(
+	"date1609459200000+",
+	"Europe/Paris",
+);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedOffset, number, "strict">;
+

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

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.getWeekOfYear
+ *
+ * Lire le numéro ISO de la semaine d’une date, 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 week = DChrono.getWeekOfYear(date);
+
+// La valeur obtenue est 2 pour le 15 janvier 2021.
+type _CheckWeek = DCommon.ExpectType<typeof week, number, "strict">;
+
+const inNewYork = DChrono.getWeekOfYear(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getWeekOfYear("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,27 @@
+/**
+ * @title DChrono.getYear
+ *
+ * Lire l’année d’une date en UTC ou dans un fuseau horaire donné.
+ */
+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 year = DChrono.getYear(date);
+
+// La valeur obtenue est 2021.
+type _CheckYear = DCommon.ExpectType<typeof year, number, "strict">;
+
+const inNewYork = DChrono.getYear(date, "America/New_York");
+type _CheckTimezone = DCommon.ExpectType<typeof inNewYork, number, "strict">;
+
+// Une date sérialisée est également acceptée.
+const serialized = DChrono.getYear("date1609459200000+", "UTC");
+type _CheckSerialized = DCommon.ExpectType<typeof serialized, number, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.greaterThanDate
+ *
+ * Comparer deux dates avec une relation strictement supérieure.
+ */
+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-01");
+const result = DChrono.greaterThanDate(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.greaterThanDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.greaterThanDate("date1609545600000+", "date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.greaterThanOrEqualDate
+ *
+ * Comparer deux dates avec une relation supérieure ou égale.
+ */
+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.greaterThanOrEqualDate(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.greaterThanOrEqualDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.greaterThanOrEqualDate("date1609459200000+", "date1609459200000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.greaterThanOrEqualTime
+ *
+ * Comparer deux durées avec une relation supérieure ou égale.
+ */
+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.greaterThanOrEqualTime(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.greaterThanOrEqualTime(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.greaterThanOrEqualTime("time2000+", "time2000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.greaterThanTime
+ *
+ * Comparer deux durées avec une relation strictement supérieure.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const time = DChrono.createTimeOrThrow(2_000);
+const threshold = DChrono.createTimeOrThrow(1_000);
+const result = DChrono.greaterThanTime(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.greaterThanTime(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.greaterThanTime("time2000+", "time1000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

@@ -0,0 +1,36 @@
+/**
+ * @title DChrono.isDate
+ *
+ * Identifier si une valeur est une instance de TheDate et réduire son type.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const value: DCommon.AnyValue;
+const isDate = DChrono.isDate(value);
+
+// Le résultat indique si la valeur est une TheDate.
+type _CheckResult = DCommon.ExpectType<typeof isDate, boolean, "strict">;
+
+const notDate = DChrono.isDate(new Date("2021-01-15T00:00:00.000Z"));
+// Une Date native n’est pas une TheDate et produit false.
+type _CheckNotDate = DCommon.ExpectType<typeof notDate, boolean, "strict">;
+
+if (DChrono.isDate(value)) {
+	const timestamp = DChrono.toTimestamp(value);
+	type _CheckNarrowed = DCommon.ExpectType<typeof timestamp, number, "strict">;
+}
+
+// Le predicate unaire peut aussi établir TheDate dans le callback d’un pipe.
+const timestamp = DCommon.pipe(
+	value,
+	DCommon.when(
+		DChrono.isDate,
+		(date) => {
+			type _CheckDate = DCommon.ExpectType<typeof date, DChrono.TheDate, "strict">;
+
+			return DChrono.toTimestamp(date);
+		},
+	),
+);
+type _CheckTimestamp = DCommon.ExpectType<typeof timestamp, DCommon.AnyValue, "strict">;

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.isSafeTimeValue
+ *
+ * Vérifier qu’une durée entière reste dans l’intervalle sûr de TheTime.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const isSafe = DChrono.isSafeTimeValue(90_000);
+
+// La valeur obtenue est true pour cette durée entière représentable.
+type _CheckResult = DCommon.ExpectType<typeof isSafe, boolean, "strict">;
+
+const isFractional = DChrono.isSafeTimeValue(90_000.5);
+const isTooLarge = DChrono.isSafeTimeValue(DChrono.maxTimeValue);
+// Une fraction et la borne maximale sont refusées par l’intervalle sûr.
+type _CheckFractional = DCommon.ExpectType<typeof isFractional, boolean, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof isTooLarge, boolean, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.isSafeTimestamp
+ *
+ * Vérifier qu’un timestamp entier reste dans l’intervalle sûr de TheDate.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const isSafe = DChrono.isSafeTimestamp(1_609_459_200_000);
+
+// La valeur obtenue est true pour ce timestamp entier représentable.
+type _CheckResult = DCommon.ExpectType<typeof isSafe, boolean, "strict">;
+
+const isFractional = DChrono.isSafeTimestamp(1_609_459_200_000.5);
+const isTooLarge = DChrono.isSafeTimestamp(DChrono.maxTimestamp);
+// Une fraction et la borne maximale sont refusées par l’intervalle sûr.
+type _CheckFractional = DCommon.ExpectType<typeof isFractional, boolean, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof isTooLarge, boolean, "strict">;
+

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

@@ -0,0 +1,41 @@
+/**
+ * @title DChrono.isSerializedTheDate
+ *
+ * Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheDate.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const value = "date1609459200000+";
+const isSerialized = DChrono.isSerializedTheDate(value);
+
+// La valeur obtenue est true ; le prédicat garantit ensuite le type SerializedTheDate.
+type _CheckResult = DCommon.ExpectType<typeof isSerialized, boolean, "strict">;
+
+const negativeValue = "date1000-";
+const invalidValue = "2021-01-01";
+const isNegativeSerialized = DChrono.isSerializedTheDate(negativeValue);
+const isInvalidSerialized = DChrono.isSerializedTheDate(invalidValue);
+type _CheckNegative = DCommon.ExpectType<typeof isNegativeSerialized, boolean, "strict">;
+type _CheckInvalid = DCommon.ExpectType<typeof isInvalidSerialized, boolean, "strict">;
+
+if (DChrono.isSerializedTheDate(value)) {
+	const timestamp = DChrono.toTimestamp(value);
+	type _CheckNarrowed = DCommon.ExpectType<typeof timestamp, number, "strict">;
+}
+
+declare const checkedValue: string;
+
+// Le pipe valide la chaîne avant de la convertir en timestamp.
+const timestamp = DCommon.pipe(
+	checkedValue,
+	DCommon.when(
+		DChrono.isSerializedTheDate,
+		(serializedDate) => {
+			type _CheckDate = DCommon.ExpectType<typeof serializedDate, DChrono.SerializedTheDate, "strict">;
+
+			return DChrono.toTimestamp(serializedDate);
+		},
+	),
+);
+type _CheckTimestamp = DCommon.ExpectType<typeof timestamp, string | number, "strict">;

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

@@ -0,0 +1,41 @@
+/**
+ * @title DChrono.isSerializedTheTime
+ *
+ * Vérifier qu’une chaîne respecte le format sérialisé sûr d’une TheTime.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const value = "time90000+";
+const isSerialized = DChrono.isSerializedTheTime(value);
+
+// La valeur obtenue est true ; le prédicat garantit ensuite le type SerializedTheTime.
+type _CheckResult = DCommon.ExpectType<typeof isSerialized, boolean, "strict">;
+
+const negativeValue = "time1000-";
+const invalidValue = "90:000";
+const isNegativeSerialized = DChrono.isSerializedTheTime(negativeValue);
+const isInvalidSerialized = DChrono.isSerializedTheTime(invalidValue);
+type _CheckNegative = DCommon.ExpectType<typeof isNegativeSerialized, boolean, "strict">;
+type _CheckInvalid = DCommon.ExpectType<typeof isInvalidSerialized, boolean, "strict">;
+
+if (DChrono.isSerializedTheTime(value)) {
+	const timeValue = DChrono.toTimeValue(value);
+	type _CheckNarrowed = DCommon.ExpectType<typeof timeValue, number, "strict">;
+}
+
+declare const checkedValue: string;
+
+// Le pipe valide la chaîne avant de lire sa valeur temporelle.
+const timeValue = DCommon.pipe(
+	checkedValue,
+	DCommon.when(
+		DChrono.isSerializedTheTime,
+		(serializedTime) => {
+			type _CheckTime = DCommon.ExpectType<typeof serializedTime, DChrono.SerializedTheTime, "strict">;
+
+			return DChrono.toTimeValue(serializedTime);
+		},
+	),
+);
+type _CheckTimeValue = DCommon.ExpectType<typeof timeValue, string | number, "strict">;

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

@@ -0,0 +1,36 @@
+/**
+ * @title DChrono.isTime
+ *
+ * Identifier si une valeur est une instance de TheTime et réduire son type.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const value: DCommon.AnyValue;
+const isTime = DChrono.isTime(value);
+
+// Le résultat indique si la valeur est une TheTime.
+type _CheckResult = DCommon.ExpectType<typeof isTime, boolean, "strict">;
+
+const notTime = DChrono.isTime(90_000);
+// Un nombre brut n’est pas une TheTime et produit false.
+type _CheckNotTime = DCommon.ExpectType<typeof notTime, boolean, "strict">;
+
+if (DChrono.isTime(value)) {
+	const timeValue = DChrono.toTimeValue(value);
+	type _CheckNarrowed = DCommon.ExpectType<typeof timeValue, number, "strict">;
+}
+
+// Le predicate unaire peut aussi établir TheTime dans le callback d’un pipe.
+const timeValue = DCommon.pipe(
+	value,
+	DCommon.when(
+		DChrono.isTime,
+		(time) => {
+			type _CheckTime = DCommon.ExpectType<typeof time, DChrono.TheTime, "strict">;
+
+			return DChrono.toTimeValue(time);
+		},
+	),
+);
+type _CheckTimeValue = DCommon.ExpectType<typeof timeValue, DCommon.AnyValue, "strict">;