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

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

@@ -0,0 +1,23 @@
+/**
+ * @title DDataStructure.array
+ *
+ * Construire une structure de tableau à partir de la structure de ses éléments.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.array(
+	DDataStructure.string(),
+);
+const result = structure.check(["red", "blue"]);
+
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.ArrayStructure<readonly string[], readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	readonly string[],
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-arrayLengthEqual.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.arrayLengthEqual
+ *
+ * Construire une contrainte de longueur exacte et l’appliquer à une structure de tableau.
+ */
+import type * as DArray from "@duplojs/lang/array";
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.arrayLengthEqual(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.ArrayLengthEqualConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.array(DDataStructure.number(), [constraint]);
+const result = structure.check([1, 2, 3]);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	readonly number[] & DArray.LengthEqual<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-betweenThan.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.betweenThan
+ *
+ * Construire une contrainte de nombre strictement compris entre deux bornes.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.betweenThan(1, 3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.BetweenThanConstraint<1, 3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(2);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThan<1> & DNumber.LessThan<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-betweenThanOrEqual.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.betweenThanOrEqual
+ *
+ * Construire une contrainte de nombre compris entre deux bornes inclusives.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.betweenThanOrEqual(1, 3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.BetweenThanOrEqualConstraint<1, 3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(1);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThanOrEqual<1> & DNumber.LessThanOrEqual<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-bigint.ts

@@ -0,0 +1,22 @@
+/**
+ * @title DDataStructure.bigint
+ *
+ * Construire une structure représentant des valeurs `bigint`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.bigint();
+const result = structure.check(42n);
+
+// La structure représente le type indiqué par son contrat.
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.TypeStructure<bigint, readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	bigint,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-boolean.ts

@@ -0,0 +1,22 @@
+/**
+ * @title DDataStructure.boolean
+ *
+ * Construire une structure représentant des valeurs booléennes.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.boolean();
+const result = structure.check(true);
+
+// La structure représente le type indiqué par son contrat.
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.TypeStructure<boolean, readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	boolean,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-createCodec.ts

@@ -0,0 +1,45 @@
+/**
+ * @title DDataStructure.createCodec
+ *
+ * Définir la conversion entre la valeur interne d’un type fondamental et sa représentation encodée.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DString from "@duplojs/lang/string";
+
+// Ce codec représente les nombres en chaînes numériques.
+// Le prédicat décrit la forme encodée que `decode` accepte et que `encode`
+// doit produire.
+const numberStringCodec = DDataStructure.createCodec(
+	DDataStructure.TheNumber,
+	(data): data is string => (
+		typeof data === "string"
+		&& DString.isNumber(data)
+	),
+	(number) => number.toString(),
+	(encodedNumber) => Number(encodedNumber),
+);
+
+// Le type du codec conserve à la fois le type fondamental représenté
+// et le type de sa valeur externe.
+type _CheckCodec = DCommon.ExpectType<
+	typeof numberStringCodec,
+	DDataStructure.Codec<DDataStructure.TheNumber, string>,
+	"strict"
+>;
+
+// `predicateEncode` est également un prédicat TypeScript pour la valeur encodée.
+const unknownEncodedValue: unknown = "42";
+if (numberStringCodec.predicateEncode(unknownEncodedValue)) {
+	type _CheckEncodedValue = DCommon.ExpectType<
+		typeof unknownEncodedValue,
+		string,
+		"strict"
+	>;
+}
+
+// `encode` transforme une valeur du type fondamental en représentation externe.
+const encodedValue = numberStringCodec.encode(42);
+
+// `decode` vérifie la représentation externe puis reconstruit la valeur interne.
+const decodedValue = numberStringCodec.decode("42");

package/docs/API/10-lang/10-dataStructure/10-createCodecs.ts

@@ -0,0 +1,134 @@
+/**
+ * @title DDataStructure.createCodecs
+ *
+ * Regrouper des codecs dans un contexte indexé par leurs types fondamentaux.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+
+const numberStringCodec = DDataStructure.createCodec(
+	DDataStructure.TheNumber,
+	(data): data is string => typeof data === "string",
+	(number) => number.toString(),
+	(encodedNumber) => Number(encodedNumber),
+);
+
+const booleanStringCodec = DDataStructure.createCodec(
+	DDataStructure.TheBoolean,
+	(data): data is string => data === "true" || data === "false",
+	(boolean) => boolean.toString(),
+	(encodedBoolean) => encodedBoolean === "true",
+);
+
+// Le mapper conserve les noms des codecs et leurs types précis.
+const codecs = DDataStructure.createCodecs({
+	number: numberStringCodec,
+	boolean: booleanStringCodec,
+});
+
+type _CheckCodecs = DCommon.ExpectType<
+	typeof codecs,
+	DDataStructure.Codecs<{
+		number: typeof numberStringCodec;
+		boolean: typeof booleanStringCodec;
+	}>,
+	"strict"
+>;
+
+// Le contexte mémorisé permet de retrouver un codec à partir du type fondamental.
+const numberCodecFromContext = codecs.context.value.get(DDataStructure.TheNumber);
+const booleanCodecFromContext = codecs.context.value.get(DDataStructure.TheBoolean);
+
+// `EncodedValue` applique le contexte aux valeurs qui correspondent à un codec.
+type _CheckEncodedNumber = DCommon.ExpectType<
+	DDataStructure.EncodedValue<number, typeof codecs>,
+	string,
+	"strict"
+>;
+type _CheckEncodedBoolean = DCommon.ExpectType<
+	DDataStructure.EncodedValue<boolean, typeof codecs>,
+	string,
+	"strict"
+>;
+
+// Une valeur sans codec associé conserve sa représentation d’origine.
+type _CheckUnencodedNull = DCommon.ExpectType<
+	DDataStructure.EncodedValue<null, typeof codecs>,
+	null,
+	"strict"
+>;
+
+// Le même contexte peut être fourni à une structure pour encoder et décoder
+// plusieurs types fondamentaux avec leurs codecs respectifs.
+const structure = DDataStructure.object({
+	amount: DDataStructure.number(),
+	active: DDataStructure.boolean(),
+});
+const encoded = structure.encode(codecs, {
+	amount: 12.5,
+	active: true,
+});
+const decoded = structure.decode(codecs, {
+	amount: "12.5",
+	active: "true",
+});
+
+// Le retour est un `Either` : la branche de droite contient la valeur encodée,
+// tandis que les branches de gauche décrivent une erreur asynchrone ou métier.
+type _CheckEncodedResult = DCommon.ExpectType<
+	typeof encoded,
+	| DEither.Right<
+		"encode-success",
+		{
+			readonly amount: string;
+			readonly active: string;
+		}
+	>
+	| DEither.Left<"async-error", DDataStructure.ErrorPromise>
+	| DEither.Left<"encode-error", DDataStructure.Error>,
+	"strict"
+>;
+
+type _CheckDecodedResult = DCommon.ExpectType<
+	typeof decoded,
+	| DEither.Right<
+		"decode-success",
+		{
+			readonly amount: number;
+			readonly active: boolean;
+		}
+	>
+	| DEither.Left<"async-error", DDataStructure.ErrorPromise>
+	| DEither.Left<"decode-error", DDataStructure.Error>,
+	"strict"
+>;
+
+// Après extraction de la branche de succès, les codecs sont visibles dans
+// le type de sortie : les deux propriétés externes sont des chaînes.
+const encodedValue = DCommon.pipe(
+	encoded,
+	DEither.unwrapByInformationOrThrow("encode-success"),
+);
+type _CheckEncodedValue = DCommon.ExpectType<
+	typeof encodedValue,
+	{
+		readonly amount: string;
+		readonly active: string;
+	},
+	"strict"
+>;
+
+// Le décodage reconstruit le type interne de la structure.
+const decodedValue = DCommon.pipe(
+	decoded,
+	DEither.unwrapByInformationOrThrow("decode-success"),
+);
+type _CheckDecodedValue = DCommon.ExpectType<
+	typeof decodedValue,
+	{
+		readonly amount: number;
+		readonly active: boolean;
+	},
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-createErrorInterpreter.ts

@@ -0,0 +1,74 @@
+/**
+ * @title DDataStructure.createErrorInterpreter
+ *
+ * Transformer les issues d’une erreur de validation ou de codec en messages interprétables.
+ */
+import * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+
+const userStructure = DDataStructure.object({
+	email: DDataStructure.string([DDataStructure.email()]),
+	age: DDataStructure.number([DDataStructure.greaterThanOrEqual(18)]),
+});
+
+const checkResult = userStructure.check({
+	email: "invalid-email",
+	age: 12,
+});
+
+// Une erreur conserve les sources techniques de chaque issue : structure,
+// type, contrainte ou codec.
+const error = DCommon.pipe(
+	checkResult,
+	DEither.unwrapByInformationOrThrow("check-error"),
+);
+
+type _CheckError = DCommon.ExpectType<
+	typeof error,
+	DDataStructure.Error,
+	"strict"
+>;
+
+// Les dictionnaires par défaut produisent des messages génériques pour les
+// structures, types, contraintes et codecs fournis par DuploJS.
+const dataStructureDictionary = {
+	...DDataStructure.defaultErrorInterpreterDataStructureDictionary,
+	"@DuplojsLangDataStructure/email-constraint": (source, issue) => {
+		type _CheckSource = DCommon.ExpectType<
+			typeof source,
+			DDataStructure.EmailConstraint,
+			"strict"
+		>;
+		type _CheckIssue = DCommon.ExpectType<
+			typeof issue,
+			DDataStructure.Issue,
+			"strict"
+		>;
+
+		return `Invalid email at ${issue.path}: ${source.definition.message}`;
+	},
+	"@DuplojsLangDataStructure/greater-than-or-equal-constraint": (source) => (
+		`Expected a value greater than or equal to ${source.definition.threshold}.`
+	),
+} satisfies DDataStructure.StructureDictionaryParams;
+
+const interpretError = DDataStructure.createErrorInterpreter(
+	dataStructureDictionary,
+	DDataStructure.defaultErrorInterpreterCodecDictionary,
+);
+
+// L’interpréteur renvoie une issue enrichie, sans perdre la donnée, le chemin
+// ni la source de l’erreur d’origine.
+const interpretedIssues = interpretError(error);
+
+type _CheckInterpretedIssues = DCommon.ExpectType<
+	typeof interpretedIssues,
+	readonly DDataStructure.InterpretedIssues[],
+	"strict"
+>;
+
+// Les dictionnaires peuvent être omis lorsque l’application veut seulement
+// enrichir les issues avec leurs champs `interpretedMessage` optionnels.
+const interpretWithoutDictionaries = DDataStructure.createErrorInterpreter();
+const uninterpretedIssues = interpretWithoutDictionaries(error);

package/docs/API/10-lang/10-dataStructure/10-date.ts

@@ -0,0 +1,23 @@
+/**
+ * @title DDataStructure.date
+ *
+ * Construire une structure représentant les dates DuploJS.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DChrono from "@duplojs/lang/chrono";
+
+const structure = DDataStructure.date();
+const result = structure.check(new Date("2024-01-01T00:00:00.000Z"));
+
+// La structure représente le type indiqué par son contrat.
+type _CheckStructure = DCommon.ExpectType<
+	typeof structure,
+	DDataStructure.TypeStructure<DChrono.TheDate, readonly []>,
+	"strict"
+>;
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	DChrono.TheDate,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-email.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.email
+ *
+ * Construire une contrainte d’adresse email et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DString from "@duplojs/lang/string";
+
+const emailConstraint = DDataStructure.email();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof emailConstraint,
+	DDataStructure.EmailConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.string([emailConstraint]);
+const result = structure.check("jane@example.com");
+
+// Après validation, la valeur représente une chaîne portant la garantie Email.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	string & DString.Email,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-endsWith.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DDataStructure.endsWith
+ *
+ * Construire une contrainte de suffixe et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.endsWith(".json");
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.EndsWithConstraint<".json">,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("settings.json");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	`${string}.json`,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-even.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.even
+ *
+ * Construire une contrainte de nombre pair et l’appliquer à une structure numérique.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.even();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.EvenConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(8);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.Even,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-extend.ts

@@ -0,0 +1,27 @@
+/**
+ * @title DDataStructure.extend
+ *
+ * Étendre une structure objet en ajoutant ou en remplaçant des propriétés.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const source = DDataStructure.object({
+	name: DDataStructure.string(),
+});
+const structure = DDataStructure.extend(source, {
+	id: DDataStructure.number(),
+});
+const result = structure.check({
+	name: "Jane",
+	id: 1,
+});
+
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	{
+		readonly name: string;
+		readonly id: number;
+	},
+	"strict"
+>;

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

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.greaterThan
+ *
+ * Construire une contrainte de nombre supérieur à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.greaterThan(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.GreaterThanConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(4);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThan<3>,
+	"strict"
+>;

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

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.greaterThanOrEqual
+ *
+ * Construire une contrainte de nombre supérieur ou égal à un seuil.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.greaterThanOrEqual(3);
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.GreaterThanOrEqualConstraint<3>,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(3);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.GreaterThanOrEqual<3>,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-include.ts

@@ -0,0 +1,24 @@
+/**
+ * @title DDataStructure.include
+ *
+ * Construire une contrainte d’inclusion et l’appliquer à une structure de chaîne.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const constraint = DDataStructure.include("lang");
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.IncludeConstraint<"lang">,
+	"strict"
+>;
+
+const structure = DDataStructure.string([constraint]);
+const result = structure.check("duplo-lang");
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	`${string}lang${string}`,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-integer.ts

@@ -0,0 +1,25 @@
+/**
+ * @title DDataStructure.integer
+ *
+ * Construire une contrainte de nombre entier et l’appliquer à une structure numérique.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import type * as DNumber from "@duplojs/lang/number";
+
+const constraint = DDataStructure.integer();
+type _CheckConstraint = DCommon.ExpectType<
+	typeof constraint,
+	DDataStructure.IntegerConstraint,
+	"strict"
+>;
+
+const structure = DDataStructure.number([constraint]);
+const result = structure.check(42);
+
+// Une validation réussie expose une valeur portant le type du contrat.
+type _CheckStructureValue = DCommon.ExpectType<
+	DDataStructure.StructureValue<typeof structure>,
+	number & DNumber.Integer,
+	"strict"
+>;

package/docs/API/10-lang/10-dataStructure/10-isNullStructure.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isNullStructure
+ *
+ * Vérifier qu’une structure représente exactement le type `null`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.null();
+const result = DDataStructure.isNullStructure(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-isNullable.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isNullable
+ *
+ * Vérifier qu’une structure accepte la valeur `null`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.nullable(DDataStructure.string());
+const result = DDataStructure.isNullable(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;

package/docs/API/10-lang/10-dataStructure/10-isOptional.ts

@@ -0,0 +1,12 @@
+/**
+ * @title DDataStructure.isOptional
+ *
+ * Vérifier qu’une structure accepte la valeur `undefined`.
+ */
+import type * as DCommon from "@duplojs/lang/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+
+const structure = DDataStructure.optional(DDataStructure.string());
+const result = DDataStructure.isOptional(structure);
+
+type _CheckResult = DCommon.ExpectType<typeof result, boolean, "strict">;