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

package/docs/API/10-lang/10-number/10-greaterThan.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.greaterThan
+ *
+ * Tester ou établir qu’un nombre est strictement supérieur à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.greaterThan(8, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.greaterThan(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThan<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.greaterThan(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThan<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est supérieur à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-greaterThanOrEqual.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.greaterThanOrEqual
+ *
+ * Tester ou établir qu’un nombre est supérieur ou égal à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.greaterThanOrEqual(5, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car l’égalité est acceptée.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.greaterThanOrEqual(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThanOrEqual<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.greaterThanOrEqual(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.GreaterThanOrEqual<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est supérieur ou égal à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-isEven.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isEven
+ *
+ * Vérifier qu’un nombre est pair et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Even.
+if (DNumber.isEven(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Even, "strict">;
+}
+
+const result = DNumber.isEven(4);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isEven,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Even, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isInteger.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isInteger
+ *
+ * Vérifier qu’un nombre est entier et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Integer.
+if (DNumber.isInteger(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Integer, "strict">;
+}
+
+const result = DNumber.isInteger(4);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isInteger,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Integer, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isMultipleOf.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.isMultipleOf
+ *
+ * Tester ou établir qu’un nombre est un multiple d’une valeur donnée.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.isMultipleOf(12, 3);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.isMultipleOf(value, 3)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.MultipleOf<3>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isMultipleOf(3),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.MultipleOf<3>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est multiple de 3.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-isNegative.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isNegative
+ *
+ * Vérifier qu’un nombre est négatif ou nul et établir cette contrainte.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Negative.
+if (DNumber.isNegative(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Negative, "strict">;
+}
+
+const result = DNumber.isNegative(0);
+// La valeur obtenue est true : zéro appartient à cette contrainte.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isNegative,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Negative, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isNotZero.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isNotZero
+ *
+ * Vérifier qu’un nombre est différent de zéro et établir cette contrainte.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte NotZero.
+if (DNumber.isNotZero(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.NotZero, "strict">;
+}
+
+const result = DNumber.isNotZero(2);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isNotZero,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.NotZero, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isOdd.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isOdd
+ *
+ * Vérifier qu’un nombre est impair et établir cette contrainte dans le type.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Odd.
+if (DNumber.isOdd(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Odd, "strict">;
+}
+
+const result = DNumber.isOdd(3);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isOdd,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Odd, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isPositive.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isPositive
+ *
+ * Vérifier qu’un nombre est positif ou nul et établir cette contrainte.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Positive.
+if (DNumber.isPositive(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Positive, "strict">;
+}
+
+const result = DNumber.isPositive(0);
+// La valeur obtenue est true : zéro appartient à cette contrainte.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isPositive,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Positive, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isSafe.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isSafe
+ *
+ * Vérifier qu’un nombre est fini, non-NaN et représentable avec une précision sûre.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte Safe.
+if (DNumber.isSafe(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Safe, "strict">;
+}
+
+const result = DNumber.isSafe(42);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isSafe,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Safe, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isStrictNegative.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DNumber.isStrictNegative
+ *
+ * Vérifier qu’un nombre est strictement négatif et établir cette contrainte.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test runtime est strictement négatif.
+if (DNumber.isStrictNegative(value)) {
+	// Le test runtime est strict ; la signature établit la contrainte Negative exposée par l’API.
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.Negative, "strict">;
+}
+
+const result = DNumber.isStrictNegative(-1);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isStrictNegative,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.Negative, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-isStrictPositive.ts

@@ -0,0 +1,33 @@
+/**
+ * @title DNumber.isStrictPositive
+ *
+ * Vérifier qu’un nombre est strictement positif et établir cette contrainte.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const value: number;
+
+// Appel classique : le test réussi affine la valeur avec la contrainte StrictPositive.
+if (DNumber.isStrictPositive(value)) {
+	type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.StrictPositive, "strict">;
+}
+
+const result = DNumber.isStrictPositive(1);
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Le même predicate peut servir d’étape unaire dans un pipe.
+const sum = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.isStrictPositive,
+		(number) => {
+			type _CheckNumber = DCommon.ExpectType<typeof number, number & DNumber.StrictPositive, "strict">;
+
+			return DNumber.sum([number]);
+		},
+	),
+);
+// La contrainte a servi à accepter l’entrée ; la somme n’en porte pas la preuve.
+type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;

package/docs/API/10-lang/10-number/10-lessThan.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.lessThan
+ *
+ * Tester ou établir qu’un nombre est strictement inférieur à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.lessThan(3, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.lessThan(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.LessThan<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.lessThan(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.LessThan<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est inférieur à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-lessThanOrEqual.ts

@@ -0,0 +1,35 @@
+/**
+ * @title DNumber.lessThanOrEqual
+ *
+ * Tester ou établir qu’un nombre est inférieur ou égal à une borne.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.lessThanOrEqual(5, 5);
+// Appel classique : tester directement une valeur.
+// La valeur obtenue est true, car l’égalité est acceptée.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+declare const value: number;
+
+if (DNumber.lessThanOrEqual(value, 5)) {
+	type _CheckIfValue = DCommon.ExpectType<typeof value, number & DNumber.LessThanOrEqual<5>, "strict">;
+	const sum = DNumber.sum([value]);
+	type _CheckSum = DCommon.ExpectType<typeof sum, number, "strict">;
+}
+
+// Appel curifié : passer le predicate directement à DCommon.when.
+const transformed = DCommon.pipe(
+	value,
+	DCommon.when(
+		DNumber.lessThanOrEqual(5),
+		(value) => {
+			type _CheckValue = DCommon.ExpectType<typeof value, number & DNumber.LessThanOrEqual<5>, "strict">;
+
+			return DNumber.sum([value]);
+		},
+	),
+);
+// La valeur est le nombre d’entrée lorsqu’il est inférieur ou égal à 5.
+type _CheckTransformed = DCommon.ExpectType<typeof transformed, number, "strict">;

package/docs/API/10-lang/10-number/10-max.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.max
+ *
+ * Retourner le plus grand nombre d’une collection non vide.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly [3, 8, 2];
+const result = DNumber.max(values);
+// La valeur obtenue est 8.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DNumber.max,
+);
+// La valeur obtenue est le maximum de la collection, ici 8.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-number/10-maxOf.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.maxOf
+ *
+ * Calculer le maximum d’une collection non vide avec un parcours explicite.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly [3, 8, 2];
+const result = DNumber.maxOf(values);
+// La valeur obtenue est 8.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DNumber.maxOf,
+);
+// La valeur obtenue est le maximum de la collection, ici 8.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-number/10-min.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.min
+ *
+ * Retourner le plus petit nombre d’une collection non vide.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly [3, 1, 8];
+const result = DNumber.min(values);
+// La valeur obtenue est 1.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DNumber.min,
+);
+// La valeur obtenue est le minimum de la collection, ici 1.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-number/10-minOf.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.minOf
+ *
+ * Calculer le minimum d’une collection non vide avec un parcours explicite.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly [3, 1, 8];
+const result = DNumber.minOf(values);
+// La valeur obtenue est 1.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DNumber.minOf,
+);
+// La valeur obtenue est le minimum de la collection, ici 1.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-number/10-sort.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.sort
+ *
+ * Trier une copie d’une collection de nombres dans l’ordre croissant ou décroissant.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const values: readonly number[] = [3, 1, 2];
+const result = DNumber.sort(values, "ASC");
+// La valeur obtenue est une nouvelle collection [1, 2, 3].
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+const piped = DCommon.pipe(
+	values,
+	DNumber.sort("DSC"),
+);
+// La valeur obtenue est une nouvelle collection [3, 2, 1].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;

package/docs/API/10-lang/10-number/10-sum.ts

@@ -0,0 +1,19 @@
+/**
+ * @title DNumber.sum
+ *
+ * Additionner les nombres d’une collection.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const result = DNumber.sum([3, 1, 2]);
+// La valeur obtenue est 6.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+const values: readonly number[] = [3, 1, 2];
+const piped = DCommon.pipe(
+	values,
+	DNumber.sum,
+);
+// La valeur obtenue est la somme de la collection, ici 6.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;