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

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">;

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

@@ -0,0 +1,26 @@
+/**
+ * @title DChrono.lessThanDate
+ *
+ * Comparer deux dates avec une relation strictement inférieure.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+const date = DChrono.createDate("2021-01-01");
+const threshold = DChrono.createDate("2021-01-15");
+const result = DChrono.lessThanDate(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.lessThanDate(threshold),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;
+
+// Les formes sérialisées peuvent être comparées directement.
+const serializedResult = DChrono.lessThanDate("date1609459200000+", "date1609545600000+");
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, boolean, "strict">;
+

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.makeSafeTimeValue
+ *
+ * Ramener une durée vers un entier compris dans l’intervalle sûr de TheTime.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const rounded = DChrono.makeSafeTimeValue(90_000.4);
+const fromNaN = DChrono.makeSafeTimeValue(Number.NaN);
+const fromTooLarge = DChrono.makeSafeTimeValue(DChrono.maxTimeValue + 1);
+const fromTooSmall = DChrono.makeSafeTimeValue(DChrono.minTimeValue - 1);
+
+// Les fractions sont arrondies et NaN devient zéro.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, number, "strict">;
+type _CheckNaN = DCommon.ExpectType<typeof fromNaN, number, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof fromTooLarge, number, "strict">;
+type _CheckTooSmall = DCommon.ExpectType<typeof fromTooSmall, number, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.makeSafeTimestamp
+ *
+ * Ramener un timestamp vers un entier compris dans l’intervalle sûr de TheDate.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const rounded = DChrono.makeSafeTimestamp(1_609_459_200_000.4);
+const fromNaN = DChrono.makeSafeTimestamp(Number.NaN);
+const fromTooLarge = DChrono.makeSafeTimestamp(DChrono.maxTimestamp + 1);
+const fromTooSmall = DChrono.makeSafeTimestamp(DChrono.minTimestamp - 1);
+
+// Les fractions sont arrondies et NaN devient zéro.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, number, "strict">;
+type _CheckNaN = DCommon.ExpectType<typeof fromNaN, number, "strict">;
+type _CheckTooLarge = DCommon.ExpectType<typeof fromTooLarge, number, "strict">;
+type _CheckTooSmall = DCommon.ExpectType<typeof fromTooSmall, number, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.maxDate
+ *
+ * Retourner la date la plus éloignée dans le futur parmi plusieurs dates.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const latest = DChrono.maxDate(dates);
+
+// La valeur obtenue est la date du 15 janvier.
+type _CheckLatest = DCommon.ExpectType<typeof latest, DChrono.TheDate, "strict">;
+
+// Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const latestMixed = DChrono.maxDate(mixedDates);
+type _CheckMixed = DCommon.ExpectType<typeof latestMixed, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.maxTime
+ *
+ * Retourner la durée de valeur maximale parmi plusieurs durées.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const longest = DChrono.maxTime(times);
+
+// La valeur obtenue représente 2 000 millisecondes.
+type _CheckLongest = DCommon.ExpectType<typeof longest, DChrono.TheTime, "strict">;
+
+// Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const longestMixed = DChrono.maxTime(mixedTimes);
+type _CheckMixed = DCommon.ExpectType<typeof longestMixed, DChrono.TheTime, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.minDate
+ *
+ * Retourner la date la plus éloignée dans le passé parmi plusieurs dates.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const dates: [DChrono.TheDate, DChrono.TheDate];
+const earliest = DChrono.minDate(dates);
+
+// La valeur obtenue est la date du 1er janvier.
+type _CheckEarliest = DCommon.ExpectType<typeof earliest, DChrono.TheDate, "strict">;
+
+// Les éléments peuvent être un mélange de TheDate et de dates sérialisées.
+declare const mixedDates: [DChrono.TheDate | DChrono.SerializedTheDate, DChrono.TheDate | DChrono.SerializedTheDate];
+const earliestMixed = DChrono.minDate(mixedDates);
+type _CheckMixed = DCommon.ExpectType<typeof earliestMixed, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,19 @@
+/**
+ * @title DChrono.minTime
+ *
+ * Retourner la durée de valeur minimale parmi plusieurs durées.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+declare const times: [DChrono.TheTime, DChrono.TheTime];
+const shortest = DChrono.minTime(times);
+
+// La valeur obtenue représente 1 000 millisecondes.
+type _CheckShortest = DCommon.ExpectType<typeof shortest, DChrono.TheTime, "strict">;
+
+// Les éléments peuvent être un mélange de TheTime et de durées sérialisées.
+declare const mixedTimes: [DChrono.TheTime | DChrono.SerializedTheTime, DChrono.TheTime | DChrono.SerializedTheTime];
+const shortestMixed = DChrono.minTime(mixedTimes);
+type _CheckMixed = DCommon.ExpectType<typeof shortestMixed, DChrono.TheTime, "strict">;
+

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

@@ -0,0 +1,13 @@
+/**
+ * @title DChrono.now
+ *
+ * Créer une TheDate représentant l’instant courant.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const current = DChrono.now();
+
+// La valeur dépend de l’horloge au moment de l’appel, mais reste une TheDate.
+type _CheckCurrent = DCommon.ExpectType<typeof current, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,41 @@
+/**
+ * @title DChrono.round
+ *
+ * Ramener une date au début de l’unité UTC demandée.
+ */
+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 rounded = DChrono.round(date, "day");
+
+// La sortie représente le début du 15 janvier en UTC.
+type _CheckRounded = DCommon.ExpectType<typeof rounded, DChrono.TheDate, "strict">;
+
+// Sans unité, le jour est utilisé par défaut.
+const defaultRounded = DChrono.round(date);
+type _CheckDefault = DCommon.ExpectType<typeof defaultRounded, DChrono.TheDate, "strict">;
+
+// Les autres unités de RoundUnit ramènent la date au début de leur période UTC.
+const roundedSecond = DChrono.round(date, "second");
+const roundedMinute = DChrono.round(date, "minute");
+const roundedHour = DChrono.round(date, "hour");
+const roundedMonth = DChrono.round(date, "month");
+const roundedYear = DChrono.round(date, "year");
+
+type _CheckUnits = DCommon.ExpectType<
+	[typeof roundedSecond, typeof roundedMinute, typeof roundedHour, typeof roundedMonth, typeof roundedYear],
+	[DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate, DChrono.TheDate],
+	"strict"
+>;
+
+// Une date sérialisée peut aussi être arrondie.
+const roundedSerialized = DChrono.round("date1610714096789+", "hour");
+type _CheckSerialized = DCommon.ExpectType<typeof roundedSerialized, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,23 @@
+/**
+ * @title DChrono.serialize
+ *
+ * Convertir une TheDate ou une TheTime en chaîne sérialisée.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import type * as DCommon from "@duplojs/lang/common";
+
+const serializedDate = DChrono.serialize(DChrono.createDate("2021-01-01"));
+const serializedTime = DChrono.serialize(DChrono.createTimeOrThrow(2_500));
+
+// Les résultats portent respectivement les formats SerializedTheDate et SerializedTheTime.
+type _CheckDate = DCommon.ExpectType<typeof serializedDate, DChrono.SerializedTheDate, "strict">;
+type _CheckTime = DCommon.ExpectType<typeof serializedTime, DChrono.SerializedTheTime, "strict">;
+
+// Le signe encode aussi les valeurs antérieures à l’époque Unix.
+const serializedPastDate = DChrono.serialize(DChrono.createDateOrThrow(-1_000));
+const serializedNegativeTime = DChrono.serialize(DChrono.createTimeOrThrow(-2_500));
+
+// Les résultats restent respectivement des chaînes de date et de durée sérialisées.
+type _CheckPastDate = DCommon.ExpectType<typeof serializedPastDate, DChrono.SerializedTheDate, "strict">;
+type _CheckNegativeTime = DCommon.ExpectType<typeof serializedNegativeTime, DChrono.SerializedTheTime, "strict">;
+

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

@@ -0,0 +1,30 @@
+/**
+ * @title DChrono.sortDates
+ *
+ * Trier des dates par ordre croissant ou décroissant.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const dates: readonly [DChrono.TheDate, DChrono.TheDate];
+const ascending = DChrono.sortDates(dates, "ASC");
+
+// La nouvelle collection est triée du 1er au 15 janvier.
+type _CheckAscending = DCommon.ExpectType<typeof ascending, DChrono.TheDate[], "strict">;
+
+// La forme curifiée fixe l’ordre dans le pipe.
+const descending = DCommon.pipe(
+	dates,
+	DChrono.sortDates("DSC"),
+);
+type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheDate[], "strict">;
+
+// Une collection peut mélanger dates sérialisées et TheDate.
+declare const mixedDates: readonly [
+	DChrono.TheDate | DChrono.SerializedTheDate,
+	DChrono.TheDate | DChrono.SerializedTheDate,
+];
+const mixed = DChrono.sortDates(mixedDates, "ASC");
+type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheDate[], "strict">;
+

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

@@ -0,0 +1,29 @@
+/**
+ * @title DChrono.sortTimes
+ *
+ * Trier des durées par ordre croissant ou décroissant.
+ */
+import * as DChrono from "@duplojs/lang/chrono";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const times: readonly [DChrono.TheTime, DChrono.TheTime];
+const ascending = DChrono.sortTimes(times, "ASC");
+
+// La nouvelle collection est triée de 1 000 à 2 000 millisecondes.
+type _CheckAscending = DCommon.ExpectType<typeof ascending, DChrono.TheTime[], "strict">;
+
+// La forme curifiée fixe l’ordre dans le pipe.
+const descending = DCommon.pipe(
+	times,
+	DChrono.sortTimes("DSC"),
+);
+type _CheckDescending = DCommon.ExpectType<typeof descending, DChrono.TheTime[], "strict">;
+
+// Une collection peut mélanger durées sérialisées et TheTime.
+declare const mixedTimes: readonly [
+	DChrono.TheTime | DChrono.SerializedTheTime,
+	DChrono.TheTime | DChrono.SerializedTheTime,
+];
+const mixed = DChrono.sortTimes(mixedTimes, "ASC");
+type _CheckMixed = DCommon.ExpectType<typeof mixed, DChrono.TheTime[], "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractDays
+ *
+ * Soustraire un nombre de jours à 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.subtractDays(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 day 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.subtractDays(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractDays("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractHours
+ *
+ * Soustraire un nombre d’heures à 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.subtractHours(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 hour 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.subtractHours(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractHours("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMilliseconds
+ *
+ * Soustraire un nombre de millisecondes à 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.subtractMilliseconds(date, 1_000);
+
+// La sortie est une nouvelle TheDate décalée de 1_000 millisecond 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.subtractMilliseconds(1_000),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractMilliseconds("date1609459200000+", 1000);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMinutes
+ *
+ * Soustraire un nombre de minutes à 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.subtractMinutes(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 minute 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.subtractMinutes(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractMinutes("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractMonths
+ *
+ * Soustraire un nombre de mois à 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.subtractMonths(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 month 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.subtractMonths(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractMonths("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+

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

@@ -0,0 +1,25 @@
+/**
+ * @title DChrono.subtractSeconds
+ *
+ * Soustraire un nombre de secondes à 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.subtractSeconds(date, 1);
+
+// La sortie est une nouvelle TheDate décalée de 1 second 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.subtractSeconds(1),
+);
+type _CheckPiped = DCommon.ExpectType<typeof piped, DChrono.TheDate, "strict">;
+
+// Une date sérialisée est acceptée comme premier argument.
+const serializedResult = DChrono.subtractSeconds("date1609459200000+", 1);
+type _CheckSerialized = DCommon.ExpectType<typeof serializedResult, DChrono.TheDate, "strict">;
+