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

package/docs/API/10-lang/10-array/10-length.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DArray.length
+ *
+ * Lire la longueur d’un tableau avec les contraintes de cardinalité présentes dans son type.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+
+const values = [1, 2, 3];
+const result = DArray.length(values);
+
+// La valeur obtenue est 3 ; le type porte la garantie que la longueur est positive.
+type _CheckResult = DCommon.ExpectType<
+	typeof result,
+	number & DNumber.Positive,
+	"strict"
+>;
+
+// Une contrainte maximale enrichit aussi le type de la longueur.
+declare const bounded: readonly number[] & DArray.MaxElements<5>;
+const boundedLength = DArray.length(bounded);
+
+type _CheckBoundedLength = DCommon.ExpectType<
+	typeof boundedLength,
+	number & DNumber.Positive & DNumber.LessThanOrEqual<5>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-lengthEqual.ts

@@ -0,0 +1,39 @@
+/**
+ * @title DArray.lengthEqual
+ *
+ * Vérifier qu’un tableau possède exactement un nombre donné d’éléments et établir cette contrainte.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+declare const values: readonly number[];
+
+// Le test runtime établit la longueur exacte dans la branche réussie.
+if (DArray.lengthEqual(values, 2)) {
+	// La valeur d’origine est alors connue comme ayant exactement deux éléments.
+	type _CheckValues = DCommon.ExpectType<
+		typeof values,
+		readonly number[] & DArray.LengthEqual<2>,
+		"strict"
+	>;
+}
+
+// La forme curifiée affine l’entrée directement dans le callback de DCommon.when.
+const piped = DCommon.pipe(
+	values,
+	DCommon.when(
+		DArray.lengthEqual(2),
+		(array) => {
+			type _CheckArray = DCommon.ExpectType<
+				typeof array,
+				readonly number[] & DArray.LengthEqual<2>,
+				"strict"
+			>;
+
+			return DArray.first(array);
+		},
+	),
+);
+
+// La sortie est le premier nombre lorsque la longueur vaut 2, sinon le tableau d’origine.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number | readonly number[], "strict">;

package/docs/API/10-lang/10-array/10-map.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.map
+ *
+ * Transformer chaque élément d’un tableau dans une nouvelle collection.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+
+// Appel classique : chaque élément est transformé en chaîne.
+const result = DArray.map(numbers, (value) => `number-${value}`);
+
+// La valeur obtenue est ["number-1", "number-2", "number-3"].
+type _CheckResult = DCommon.ExpectType<typeof result, readonly string[], "strict">;
+
+// Appel curifié : la transformation est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.map((value) => value * 2),
+);
+
+// La valeur obtenue est [2, 4, 6].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// Une transformation qui conserve la cardinalité réapplique la borne maximale.
+declare const constrained: readonly number[] & DArray.MaxElements<3>;
+const constrainedResult = DArray.map(constrained, (value) => value * 2);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-maxElements.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DArray.maxElements
+ *
+ * Vérifier qu’un tableau contient au plus un nombre donné d’éléments et établir cette contrainte.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly number[];
+
+// Le test runtime établit une borne supérieure dans la branche réussie.
+if (DArray.maxElements(values, 3)) {
+	// La valeur d’origine est alors connue comme ayant au plus trois éléments.
+	type _CheckValues = DCommon.ExpectType<
+		typeof values,
+		readonly number[] & DArray.MaxElements<3>,
+		"strict"
+	>;
+}
+
+// La forme curifiée affine l’entrée directement dans le callback de DCommon.when.
+const piped = DCommon.pipe(
+	values,
+	DCommon.when(
+		DArray.maxElements(3),
+		(array) => {
+			type _CheckArray = DCommon.ExpectType<
+				typeof array,
+				readonly number[] & DArray.MaxElements<3>,
+				"strict"
+			>;
+
+			return DArray.length(array);
+		},
+	),
+);
+
+// La sortie est la longueur lorsque la borne est respectée, sinon le tableau d’origine.
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly number[] | (number & DNumber.Positive & DNumber.LessThanOrEqual<3>),
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-minElements.ts

@@ -0,0 +1,44 @@
+/**
+ * @title DArray.minElements
+ *
+ * Vérifier qu’un tableau contient au moins un nombre donné d’éléments et établir cette contrainte.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import type * as DNumber from "@duplojs/lang/number";
+
+declare const values: readonly number[];
+
+// Le test runtime établit une borne inférieure dans la branche réussie.
+if (DArray.minElements(values, 2)) {
+	// La valeur d’origine est alors connue comme ayant au moins deux éléments.
+	type _CheckValues = DCommon.ExpectType<
+		typeof values,
+		readonly number[] & DArray.MinElements<2>,
+		"strict"
+	>;
+}
+
+// La forme curifiée affine l’entrée directement dans le callback de DCommon.when.
+const piped = DCommon.pipe(
+	values,
+	DCommon.when(
+		DArray.minElements(2),
+		(array) => {
+			type _CheckArray = DCommon.ExpectType<
+				typeof array,
+				readonly number[] & DArray.MinElements<2>,
+				"strict"
+			>;
+
+			return DArray.length(array);
+		},
+	),
+);
+
+// La sortie est la longueur lorsque la borne est respectée, sinon le tableau d’origine.
+type _CheckPiped = DCommon.ExpectType<
+	typeof piped,
+	readonly number[] | (number & DNumber.Positive & DNumber.GreaterThanOrEqual<2>),
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-notIncludes.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DArray.notIncludes
+ *
+ * Vérifier qu’un tableau ne contient pas une valeur.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const colors: readonly string[] = ["red", "green"];
+
+// Appel classique : la valeur recherchée est absente du tableau.
+const result = DArray.notIncludes(colors, "blue");
+
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Appel curifié : la valeur est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	colors,
+	DArray.notIncludes("red"),
+);
+
+// La valeur obtenue est false.
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;

package/docs/API/10-lang/10-array/10-pop.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DArray.pop
+ *
+ * Retirer le dernier élément d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+const result = DArray.pop(numbers);
+
+// La valeur obtenue est [1, 2] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// La suppression conserve une borne maximale portée par le tableau source.
+declare const constrained: readonly number[] & DArray.MaxElements<4>;
+const constrainedResult = DArray.pop(constrained);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<4>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-prepend.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.prepend
+ *
+ * Ajouter les éléments d’un ou plusieurs tableaux au début sans muter le tableau d’entrée.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [3, 4];
+
+// Appel classique : les tableaux fournis sont placés avant numbers.
+const result = DArray.prepend(numbers, [1], [2]);
+
+// La valeur obtenue est [1, 2, 3, 4].
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : les éléments à ajouter sont fixés dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.prepend([1, 2]),
+);
+
+// La valeur obtenue est [1, 2, 3, 4].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// La contrainte minimale du tableau source est réappliquée après l’ajout au début.
+declare const constrained: readonly number[] & DArray.MinElements<2>;
+const constrainedResult = DArray.prepend(constrained, [1]);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MinElements<2>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-push.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.push
+ *
+ * Ajouter une ou plusieurs valeurs à la fin d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2];
+
+// Appel classique : plusieurs valeurs peuvent être ajoutées en une fois.
+const result = DArray.push(numbers, 3, 4);
+
+// La valeur obtenue est [1, 2, 3, 4] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : les valeurs sont configurées dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.push(3),
+);
+
+// La valeur obtenue est [1, 2, 3].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// L’ajout augmente d’un élément la borne minimale connue du tableau source.
+declare const constrained: readonly number[] & DArray.MinElements<2>;
+const constrainedResult = DArray.push(constrained, 3);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MinElements<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-reduce.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DArray.reduce
+ *
+ * Réduire un tableau avec un accumulateur explicite et les sorties next ou exit.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+
+// Appel classique : next transmet l’accumulateur à l’itération suivante.
+const result = DArray.reduce(numbers, 0, ({ element, lastValue, next }) => next(
+	lastValue + element,
+));
+
+// La valeur obtenue est 6.
+type _CheckResult = DCommon.ExpectType<typeof result, number, "strict">;
+
+// Appel curifié : l’accumulateur et le traitement sont configurés dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.reduce(0, ({ element, lastValue, next }) => next(
+		lastValue + element,
+	)),
+);
+
+// La valeur obtenue est 6.
+type _CheckPiped = DCommon.ExpectType<typeof piped, number, "strict">;

package/docs/API/10-lang/10-array/10-reduceFrom.ts

@@ -0,0 +1,16 @@
+/**
+ * @title DArray.reduceFrom
+ *
+ * Marquer explicitement la valeur initiale d’un reduce pour préserver sa forme de valeur.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+
+const initial = DArray.reduceFrom({ count: 0 });
+
+// La valeur obtenue porte la valeur initiale dans le marqueur attendu par DArray.reduce.
+type _CheckInitial = DCommon.ExpectType<
+	typeof initial,
+	DArray.ReduceFromResult<{ count: number }>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-reduceRight.ts

@@ -0,0 +1,28 @@
+/**
+ * @title DArray.reduceRight
+ *
+ * Réduire un tableau de droite à gauche avec le contrat explicite de DArray.reduce.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const values = ["a", "b", "c"];
+
+// Appel classique : les éléments sont visités de la droite vers la gauche.
+const result = DArray.reduceRight(values, "", ({ element, lastValue, next }) => next(
+	lastValue + element,
+));
+
+// La valeur obtenue est "cba".
+type _CheckResult = DCommon.ExpectType<typeof result, string, "strict">;
+
+// Appel curifié : l’accumulateur et le traitement sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	values,
+	DArray.reduceRight("", ({ element, lastValue, next }) => next(
+		lastValue + element,
+	)),
+);
+
+// La valeur obtenue est "cba".
+type _CheckPiped = DCommon.ExpectType<typeof piped, string, "strict">;

package/docs/API/10-lang/10-array/10-reverse.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DArray.reverse
+ *
+ * Inverser l’ordre d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+
+// L’ordre est inversé sans mutation de numbers.
+const result = DArray.reverse(numbers);
+
+// La valeur obtenue est [3, 2, 1].
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// L’inversion conserve la borne maximale du tableau source.
+declare const constrained: readonly number[] & DArray.MaxElements<4>;
+const constrainedResult = DArray.reverse(constrained);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<4>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-select.ts

@@ -0,0 +1,26 @@
+/**
+ * @title DArray.select
+ *
+ * Transformer sélectivement les éléments avec select et ignorer les autres avec skip.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+
+// Appel classique : les nombres pairs sont transformés et les autres ignorés.
+const result = DArray.select(numbers, ({ element, select, skip }) => element % 2 === 0
+	? select(`even-${element}`)
+	: skip());
+
+// La valeur obtenue est ["even-2"].
+type _CheckResult = DCommon.ExpectType<typeof result, `even-${number}`[], "strict">;
+
+// Appel curifié : la décision de sélection est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.select(({ element, select }) => select(element * 10)),
+);
+
+// La valeur obtenue est [10, 20, 30].
+type _CheckPiped = DCommon.ExpectType<typeof piped, number[], "strict">;

package/docs/API/10-lang/10-array/10-set.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DArray.set
+ *
+ * Remplacer la valeur à un index dans une nouvelle copie du tableau.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+
+// Appel classique : l’index est normalisé comme un index de tableau.
+const result = DArray.set(numbers, 1, 20);
+
+// La valeur obtenue est [1, 20, 3] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, number[], "strict">;
+
+// Appel curifié : l’index et la valeur sont fixés dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.set(0, 10),
+);
+
+// La valeur obtenue est [10, 2, 3].
+type _CheckPiped = DCommon.ExpectType<typeof piped, number[], "strict">;

package/docs/API/10-lang/10-array/10-shift.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DArray.shift
+ *
+ * Retirer le premier élément d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3];
+const result = DArray.shift(numbers);
+
+// La valeur obtenue est [2, 3] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// La suppression conserve une borne maximale portée par le tableau source.
+declare const constrained: readonly number[] & DArray.MaxElements<4>;
+const constrainedResult = DArray.shift(constrained);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<4>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-slice.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DArray.slice
+ *
+ * Extraire une portion d’un tableau dans une nouvelle collection.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3, 4];
+
+// Appel classique : les bornes suivent les règles de Array.prototype.slice.
+const result = DArray.slice(numbers, 1, 3);
+
+// La valeur obtenue est [2, 3].
+type _CheckResult = DCommon.ExpectType<typeof result, number[], "strict">;
+
+// Appel curifié : les bornes sont fixées dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.slice(1, 3),
+);
+
+// La valeur obtenue est [2, 3].
+type _CheckPiped = DCommon.ExpectType<typeof piped, number[], "strict">;

package/docs/API/10-lang/10-array/10-some.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DArray.some
+ *
+ * Vérifier qu’au moins un élément d’un tableau satisfait un prédicat.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+import * as DNumber from "@duplojs/lang/number";
+
+const numbers = [1, 3, 4];
+
+// Appel classique : le prédicat trouve un nombre pair.
+const result = DArray.some(numbers, DNumber.isEven);
+
+// La valeur obtenue est true.
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;
+
+// Appel curifié : le prédicat est configuré dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.some(DNumber.greaterThan(4)),
+);
+
+// La valeur obtenue est false.
+type _CheckPiped = DCommon.ExpectType<typeof piped, boolean, "strict">;

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

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.sort
+ *
+ * Trier une copie du tableau avec une fonction de comparaison.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [3, 1, 2];
+
+// Appel classique : le tri numérique est explicité par la fonction de comparaison.
+const result = DArray.sort(numbers, (first, second) => first - second);
+
+// La valeur obtenue est [1, 2, 3] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : la fonction de comparaison est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.sort((first, second) => second - first),
+);
+
+// La valeur obtenue est [3, 2, 1].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// Le tri conserve la borne maximale du tableau source.
+declare const constrained: readonly number[] & DArray.MaxElements<3>;
+const constrainedResult = DArray.sort(constrained, (first, second) => first - second);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-spliceDelete.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.spliceDelete
+ *
+ * Supprimer une portion d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3, 4];
+
+// Appel classique : supprimer deux éléments à partir de l’index 1.
+const result = DArray.spliceDelete(numbers, 1, 2);
+
+// La valeur obtenue est [1, 4] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : la portion à supprimer est configurée dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.spliceDelete(0, 1),
+);
+
+// La valeur obtenue est [2, 3, 4].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// La suppression conserve la borne maximale du tableau source.
+declare const constrained: readonly number[] & DArray.MaxElements<4>;
+const constrainedResult = DArray.spliceDelete(constrained, 1, 1);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MaxElements<4>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-spliceInsert.ts

@@ -0,0 +1,34 @@
+/**
+ * @title DArray.spliceInsert
+ *
+ * Insérer des éléments à un index dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 4];
+
+// Appel classique : insérer [2, 3] avant l’index 1.
+const result = DArray.spliceInsert(numbers, 1, [2, 3]);
+
+// La valeur obtenue est [1, 2, 3, 4].
+type _CheckResult = DCommon.ExpectType<typeof result, readonly number[], "strict">;
+
+// Appel curifié : l’index et les éléments sont configurés dans l’étape du pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.spliceInsert(1, [2, 3]),
+);
+
+// La valeur obtenue est [1, 2, 3, 4].
+type _CheckPiped = DCommon.ExpectType<typeof piped, readonly number[], "strict">;
+
+// L’insertion réapplique la contrainte minimale du tableau source.
+declare const constrained: readonly number[] & DArray.MinElements<2>;
+const constrainedResult = DArray.spliceInsert(constrained, 1, [8]);
+
+type _CheckConstrained = DCommon.ExpectType<
+	typeof constrainedResult,
+	readonly number[] & DArray.MinElements<2>,
+	"strict"
+>;

package/docs/API/10-lang/10-array/10-spliceReplace.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DArray.spliceReplace
+ *
+ * Remplacer une portion d’un tableau dans une nouvelle copie.
+ */
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+const numbers = [1, 2, 3, 4];
+
+// Appel classique : remplacer deux éléments à partir de l’index 1.
+const result = DArray.spliceReplace(numbers, 1, [8, 9]);
+
+// La valeur obtenue est [1, 8, 9, 4] ; numbers reste inchangé.
+type _CheckResult = DCommon.ExpectType<typeof result, number[], "strict">;
+
+// Appel curifié : l’index et les éléments de remplacement sont configurés dans le pipe.
+const piped = DCommon.pipe(
+	numbers,
+	DArray.spliceReplace(0, [7]),
+);
+
+// La valeur obtenue est [7, 2, 3, 4].
+type _CheckPiped = DCommon.ExpectType<typeof piped, number[], "strict">;