@duplojs/utils 1.4.51 → 1.4.53

package/dist/clean/constraint/base.cjs

@@ -3,7 +3,9 @@
 var kind = require('../kind.cjs');
 var kind$1 = require('../../common/kind.cjs');
 var coalescing = require('../../array/coalescing.cjs');
+var pipe = require('../../common/pipe.cjs');
 var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var override = require('../../common/override.cjs');
 var is = require('../../either/left/is.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 var create = require('../../either/left/create.cjs');
@@ -62,7 +64,7 @@ function createConstraint(name, primitiveHandler, checker) {
         }
         return false;
     }
-    return constraintHandlerKind.setTo({
+    return pipe.pipe({
         name,
         primitiveHandler,
         checkers,
@@ -71,8 +73,9 @@ function createConstraint(name, primitiveHandler, checker) {
         createWithUnknown: create$2,
         createWithUnknownOrThrow: createOrThrow,
         is: is$1,
-    });
+    }, constraintHandlerKind.setTo, createConstraint.overrideHandler.apply);
 }
+createConstraint.overrideHandler = override.createOverride("@duplojs/utils/clean/constraint");
 
 exports.CreateConstrainedTypeError = CreateConstrainedTypeError;
 exports.constrainedTypeKind = constrainedTypeKind;

package/dist/clean/constraint/base.d.ts

@@ -138,5 +138,8 @@ export declare function createConstraint<GenericName extends string, GenericPrim
     DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>,
     ...DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]
 ]) = never>(name: GenericName, primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, checker: GenericChecker): ConstraintHandler<GenericName, GenericPrimitiveValue, DArray.ArrayCoalescing<GenericChecker>>;
+export declare namespace createConstraint {
+    var overrideHandler: import("../..").OverrideHandler<ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[]>>;
+}
 export type GetConstraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
 export {};

package/dist/clean/constraint/base.mjs

@@ -1,7 +1,9 @@
 import { createCleanKind } from '../kind.mjs';
 import { kindHeritage } from '../../common/kind.mjs';
 import { coalescing } from '../../array/coalescing.mjs';
+import { pipe } from '../../common/pipe.mjs';
 import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { isLeft } from '../../either/left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import { left } from '../../either/left/create.mjs';
@@ -60,7 +62,7 @@ function createConstraint(name, primitiveHandler, checker) {
         }
         return false;
     }
-    return constraintHandlerKind.setTo({
+    return pipe({
         name,
         primitiveHandler,
         checkers,
@@ -69,7 +71,8 @@ function createConstraint(name, primitiveHandler, checker) {
         createWithUnknown: create,
         createWithUnknownOrThrow: createOrThrow,
         is,
-    });
+    }, constraintHandlerKind.setTo, createConstraint.overrideHandler.apply);
 }
+createConstraint.overrideHandler = createOverride("@duplojs/utils/clean/constraint");
 
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint };

package/dist/clean/constraint/defaultConstraint/number.cjs

@@ -18,7 +18,21 @@ const Positive = base.createConstraint("positive", base$1.Number, min.checkerNum
  * {@include clean/Negative/index.md}
  */
 const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(-1));
+/**
+ * {@include clean/NumberMin/index.md}
+ */
+function NumberMin(value) {
+    return base.createConstraint(`number-min-${value}`, base$1.Number, min.checkerNumberMin(value));
+}
+/**
+ * {@include clean/NumberMax/index.md}
+ */
+function NumberMax(value) {
+    return base.createConstraint(`number-max-${value}`, base$1.Number, max.checkerNumberMax(value));
+}
 
 exports.Int = Int;
 exports.Negative = Negative;
+exports.NumberMax = NumberMax;
+exports.NumberMin = NumberMin;
 exports.Positive = Positive;

package/dist/clean/constraint/defaultConstraint/number.d.ts

@@ -1,5 +1,6 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+import { type OnlyLiteralNumber } from "../../../common";
 /**
  * Constraint handler that validates integer numbers.
  * 
@@ -87,3 +88,63 @@ export type Positive = GetConstraint<typeof Positive>;
  */
 export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax]>;
 export type Negative = GetConstraint<typeof Negative>;
+/**
+ * Constraint factory that validates numbers greater than or equal to a minimum.
+ * 
+ * **Supported call styles:**
+ * - Classic: `NumberMin(min)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.Number` that enforces a value greater than or equal to `min`. Use it to validate inputs and to constrain NewTypes with a minimum value requirement.
+ * 
+ * ```ts
+ * const AdultMin = C.NumberMin(18);
+ * 
+ * const result = AdultMin.create(18);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"number-min-18", 18>>
+ * }
+ * 
+ * const age = AdultMin.createOrThrow(20);
+ * // age: C.ConstrainedType<"number-min-18", 20>
+ * 
+ * AdultMin.is(age); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMin]>;
+export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin<GenericValue>>;
+/**
+ * Constraint factory that validates numbers less than or equal to a maximum.
+ * 
+ * **Supported call styles:**
+ * - Classic: `NumberMax(max)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.Number` that enforces a value less than or equal to `max`. Use it to validate inputs and to constrain NewTypes with a maximum value requirement.
+ * 
+ * ```ts
+ * const PercentMax = C.NumberMax(100);
+ * 
+ * const result = PercentMax.create(100);
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"number-max-100", 100>>
+ * }
+ * 
+ * const value = PercentMax.createOrThrow(80);
+ * // value: C.ConstrainedType<"number-max-100", 80>
+ * 
+ * PercentMax.is(value); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax]>;
+export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax<GenericValue>>;

package/dist/clean/constraint/defaultConstraint/number.mjs

@@ -16,5 +16,17 @@ const Positive = createConstraint("positive", Number, checkerNumberMin(1));
  * {@include clean/Negative/index.md}
  */
 const Negative = createConstraint("negative", Number, checkerNumberMax(-1));
+/**
+ * {@include clean/NumberMin/index.md}
+ */
+function NumberMin(value) {
+    return createConstraint(`number-min-${value}`, Number, checkerNumberMin(value));
+}
+/**
+ * {@include clean/NumberMax/index.md}
+ */
+function NumberMax(value) {
+    return createConstraint(`number-max-${value}`, Number, checkerNumberMax(value));
+}
 
-export { Int, Negative, Positive };
+export { Int, Negative, NumberMax, NumberMin, Positive };

package/dist/clean/constraint/defaultConstraint/string.cjs

@@ -4,6 +4,8 @@ var base = require('../base.cjs');
 var base$1 = require('../../primitive/base.cjs');
 var email = require('../../../dataParser/parsers/string/checkers/email.cjs');
 var url = require('../../../dataParser/parsers/string/checkers/url.cjs');
+var min = require('../../../dataParser/parsers/string/checkers/min.cjs');
+var max = require('../../../dataParser/parsers/string/checkers/max.cjs');
 
 /**
  * {@include clean/Email/index.md}
@@ -13,6 +15,20 @@ const Email = base.createConstraint("email", base$1.String, email.checkerEmail()
  * {@include clean/Url/index.md}
  */
 const Url = base.createConstraint("url", base$1.String, url.checkerUrl());
+/**
+ * {@include clean/StringMin/index.md}
+ */
+function StringMin(value) {
+    return base.createConstraint(`string-min-${value}`, base$1.String, min.checkerStringMin(value));
+}
+/**
+ * {@include clean/StringMax/index.md}
+ */
+function StringMax(value) {
+    return base.createConstraint(`string-max-${value}`, base$1.String, max.checkerStringMax(value));
+}
 
 exports.Email = Email;
+exports.StringMax = StringMax;
+exports.StringMin = StringMin;
 exports.Url = Url;

package/dist/clean/constraint/defaultConstraint/string.d.ts

@@ -1,5 +1,6 @@
 import { type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
+import { type OnlyLiteralNumber } from "../../../common";
 /**
  * Constraint handler that validates an email string.
  * 
@@ -58,3 +59,63 @@ export type Email = GetConstraint<typeof Email>;
  */
 export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl]>;
 export type Url = GetConstraint<typeof Url>;
+/**
+ * Constraint factory that validates strings with a minimum length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `StringMin(min)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.String` that enforces a length greater than or equal to `min`. Use it to validate inputs and to constrain NewTypes with a minimum length requirement.
+ * 
+ * ```ts
+ * const UsernameMin = C.StringMin(3);
+ * 
+ * const result = UsernameMin.create("Ada");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"string-min-3", "Ada">>
+ * }
+ * 
+ * const username = UsernameMin.createOrThrow("Eve");
+ * // username: C.ConstrainedType<"string-min-3", "Eve">
+ * 
+ * UsernameMin.is(username); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMin]>;
+export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMin<GenericValue>>>;
+/**
+ * Constraint factory that validates strings with a maximum length.
+ * 
+ * **Supported call styles:**
+ * - Classic: `StringMax(max)` -> returns a constraint handler
+ * 
+ * Creates a constraint handler for `C.String` that enforces a length less than or equal to `max`. Use it to validate inputs and to constrain NewTypes with a maximum length requirement.
+ * 
+ * ```ts
+ * const TitleMax = C.StringMax(10);
+ * 
+ * const result = TitleMax.create("Hello");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"string-max-10", "Hello">>
+ * }
+ * 
+ * const title = TitleMax.createOrThrow("World");
+ * // title: C.ConstrainedType<"string-max-10", "World">
+ * 
+ * TitleMax.is(title); // type guard
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMax]>;
+export type StringMax<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMax<GenericValue>>>;

package/dist/clean/constraint/defaultConstraint/string.mjs

@@ -2,6 +2,8 @@ import { createConstraint } from '../base.mjs';
 import { String } from '../../primitive/base.mjs';
 import { checkerEmail } from '../../../dataParser/parsers/string/checkers/email.mjs';
 import { checkerUrl } from '../../../dataParser/parsers/string/checkers/url.mjs';
+import { checkerStringMin } from '../../../dataParser/parsers/string/checkers/min.mjs';
+import { checkerStringMax } from '../../../dataParser/parsers/string/checkers/max.mjs';
 
 /**
  * {@include clean/Email/index.md}
@@ -11,5 +13,17 @@ const Email = createConstraint("email", String, checkerEmail());
  * {@include clean/Url/index.md}
  */
 const Url = createConstraint("url", String, checkerUrl());
+/**
+ * {@include clean/StringMin/index.md}
+ */
+function StringMin(value) {
+    return createConstraint(`string-min-${value}`, String, checkerStringMin(value));
+}
+/**
+ * {@include clean/StringMax/index.md}
+ */
+function StringMax(value) {
+    return createConstraint(`string-max-${value}`, String, checkerStringMax(value));
+}
 
-export { Email, Url };
+export { Email, StringMax, StringMin, Url };

package/dist/clean/constraint/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./base";
 export * from "./defaultConstraint";
+export * from "./set";

package/dist/clean/constraint/set.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+var kind = require('../kind.cjs');
+var base = require('./base.cjs');
+var kind$1 = require('../../common/kind.cjs');
+var flatMap = require('../../array/flatMap.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+var pipe = require('../../common/pipe.cjs');
+var map = require('../../array/map.cjs');
+var entry = require('../../object/entry.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
+var override = require('../../common/override.cjs');
+var is = require('../../either/left/is.cjs');
+var unwrap = require('../../common/unwrap.cjs');
+var create = require('../../either/left/create.cjs');
+var create$1 = require('../../either/right/create.cjs');
+var wrapValue = require('../../common/wrapValue.cjs');
+
+const constraintsSetHandlerKind = kind.createCleanKind("constraints-set-handler");
+class CreateConstraintsSetError extends kind$1.kindHeritage("create-constraint-set-error", errorKindNamespace.createErrorKind("create-constraint-set-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create constrained type with set."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+/**
+ * {@include clean/createConstraintsSet/index.md}
+ */
+function createConstraintsSet(primitiveHandler, constraint) {
+    const constraints = coalescing.coalescing(constraint);
+    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    const constraintKindValue = pipe.pipe(constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    const wrappedConstraints = pipe.pipe(constraints, map.map((constrain) => entry.entry(constrain.name, constrain)), fromEntries.fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
+    function create$2(data) {
+        const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
+        if (is.isLeft(result)) {
+            return create.left("createConstraintsSetError", unwrap.unwrap(result));
+        }
+        else if (base.constrainedTypeKind.has(data)) {
+            return create$1.right("createConstraintsSet", base.constrainedTypeKind.addTo(data, {
+                ...base.constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }));
+        }
+        else {
+            return create$1.right("createConstraintsSet", base.constrainedTypeKind.setTo(wrapValue.wrapValue(unwrap.unwrap(result)), constraintKindValue));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create$2(data);
+        if (is.isLeft(result)) {
+            throw new CreateConstraintsSetError(data, unwrap.unwrap(result));
+        }
+        else {
+            return unwrap.unwrap(result);
+        }
+    }
+    function is$1(input) {
+        if (!base.constrainedTypeKind.has(input)) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return pipe.pipe({
+        primitiveHandler,
+        constrains: constraints,
+        getConstraint,
+        create: create$2,
+        createOrThrow,
+        createWithUnknown: create$2,
+        createWithUnknownOrThrow: createOrThrow,
+        is: is$1,
+    }, constraintsSetHandlerKind.setTo, createConstraintsSet.overrideHandler.apply);
+}
+createConstraintsSet.overrideHandler = override.createOverride("@duplojs/utils/clean/constraints-set");
+
+exports.CreateConstraintsSetError = CreateConstraintsSetError;
+exports.constraintsSetHandlerKind = constraintsSetHandlerKind;
+exports.createConstraintsSet = createConstraintsSet;

package/dist/clean/constraint/set.d.ts

@@ -0,0 +1,147 @@
+import { type Kind, type WrappedValue, type UnionToIntersection } from "../..";
+import { type GetConstraint, type ConstraintHandler } from "../constraint";
+import { type Primitive, type EligiblePrimitive, type PrimitiveHandler } from "../primitive";
+import * as DEither from "../../either";
+import * as DArray from "../../array";
+import type * as DDataParser from "../../dataParser";
+export declare const constraintsSetHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraints-set-handler", unknown>>;
+export interface ConstraintsSetHandler<GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericConstrainsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof constraintsSetHandlerKind.definition> {
+    /**
+     * The primitive handler used to validate and wrap values (e.g. `C.String`, `C.Number`).
+     * 
+     */
+    readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+    /**
+     * The list of constraint handlers applied by this set.
+     * 
+     */
+    readonly constrains: GenericConstrainsHandler;
+    /**
+     * Creates a constrained value and returns an Either.
+     * 
+     * ```ts
+     * const result = UsernameConstraints.create("Ada");
+     * 
+     * if (E.isRight(result)) {
+     * 	// result: E.Right<"createConstraintsSet", C.Primitive<"Ada"> & C.GetConstraints<typeof UsernameConstraints>>
+     * }
+     * ```
+     * 
+     */
+    create<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (DEither.Right<"createConstraintsSet", (GenericPrimitive & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value and throws on error. Works with raw values or primitives.
+     * 
+     * ```ts
+     * const value = UsernameConstraints.createOrThrow("Nova");
+     * // value: C.Primitive<"Nova"> & C.GetConstraints<typeof UsernameConstraints>
+     * 
+     * const primitive = C.String.createOrThrow("Kit");
+     * UsernameConstraints.create(primitive);
+     * ```
+     * 
+     */
+    createOrThrow<const GenericInput extends GenericPrimitiveValue>(data: GenericInput): (Primitive<GenericInput> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    createOrThrow<GenericPrimitive extends Primitive<GenericPrimitiveValue>>(data: GenericPrimitive): (GenericPrimitive & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    /**
+     * Creates a constrained value from an unknown input and returns an Either.
+     * 
+     * ```ts
+     * const unknownValue: unknown = "Sam";
+     * const maybe = UsernameConstraints.createWithUnknown(unknownValue);
+     * ```
+     * 
+     */
+    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createConstraintsSet", (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)> | DEither.Left<"createConstraintsSetError", DDataParser.DataParserError>);
+    /**
+     * Creates a constrained value from an unknown input and throws on error.
+     * 
+     * ```ts
+     * const strictValue = UsernameConstraints.createWithUnknownOrThrow(unknownValue);
+     * ```
+     * 
+     */
+    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>);
+    /**
+     * Checks if a value satisfies all constraints of the set (type guard).
+     * 
+     * ```ts
+     * UsernameConstraints.is(value); // type guard
+     * ```
+     * 
+     */
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, (Primitive<GenericPrimitiveValue> & UnionToIntersection<GenericConstrainsHandler[number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never>)>;
+    /**
+     * Returns a constraint handler by name from the constraints set.
+     * 
+     * ```ts
+     * const constraint = UsernameConstraints.getConstraint("string-max-16");
+     * constraint.createOrThrow("hello");
+     * ```
+     * 
+     */
+    getConstraint<GenericConstraintName extends GenericConstrainsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstrainsHandler[number], ConstraintHandler<GenericConstraintName>>;
+}
+declare const CreateConstraintsSetError_base: new (params: {
+    "@DuplojsUtilsError/create-constraint-set-error"?: unknown;
+}, parentParams: readonly [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & Kind<import("../..").KindDefinition<"create-constraint-set-error", unknown>, unknown> & Kind<import("../..").KindDefinition<"@DuplojsUtilsError/create-constraint-set-error", unknown>, unknown>;
+export declare class CreateConstraintsSetError extends CreateConstraintsSetError_base {
+    data: unknown;
+    dataParserError: DDataParser.DataParserError;
+    constructor(data: unknown, dataParserError: DDataParser.DataParserError);
+}
+/**
+ * Creates a constraints set handler to apply multiple constraints to a primitive.
+ * 
+ * **Supported call styles:**
+ * - Classic: `createConstraintsSet(primitiveHandler, constraints)` -> returns a handler
+ * 
+ * A constraints set validates input with the primitive DataParser, applies all constraint checkers, and tags the value with each constraint name. Use it to compose multiple constraints once and reuse the handler.
+ * 
+ * ```ts
+ * const UsernameConstraints = C.createConstraintsSet(
+ * 	C.String,
+ * 	[C.StringMin(3), C.StringMax(16)],
+ * );
+ * 
+ * const result = UsernameConstraints.create("Ada");
+ * 
+ * if (E.isRight(result)) {
+ * 	// result: E.Right<"createConstraintsSet", C.Primitive<"Ada"> & C.GetConstraints<typeof UsernameConstraints>>
+ * }
+ * 
+ * const value = UsernameConstraints.createOrThrow("Nova");
+ * // value: C.Primitive<"Nova"> & C.GetConstraints<typeof UsernameConstraints>
+ * 
+ * const primitive = C.String.createOrThrow("Kit");
+ * UsernameConstraints.create(primitive);
+ * 
+ * const unknownValue: unknown = "Sam";
+ * const maybe = UsernameConstraints.createWithUnknown(unknownValue);
+ * const strictValue = UsernameConstraints.createWithUnknownOrThrow(unknownValue);
+ * 
+ * UsernameConstraints.is(value); // type guard
+ * 
+ * const constraint = UsernameConstraints.getConstraint("string-max-16");
+ * constraint.createOrThrow("hello");
+ * ```
+ * 
+ * @remarks
+ * - You can pass a single constraint handler or a tuple of constraints.
+ * - The handler accepts both raw values and primitives.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
+ * 
+ * @namespace C
+ * 
+ */
+export declare function createConstraintsSet<GenericPrimitiveValue extends EligiblePrimitive, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]> | readonly [
+    ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>,
+    ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, GenericPrimitiveValue>[]>[]
+]) = never>(primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>, constraint: GenericConstrainHandler): ConstraintsSetHandler<GenericPrimitiveValue, DArray.ArrayCoalescing<GenericConstrainHandler>>;
+export declare namespace createConstraintsSet {
+    var overrideHandler: import("../..").OverrideHandler<ConstraintsSetHandler<EligiblePrimitive, readonly []>>;
+}
+export type GetConstraints<GenericHandler extends ConstraintsSetHandler<EligiblePrimitive, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["constrains"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
+export {};

package/dist/clean/constraint/set.mjs

@@ -0,0 +1,91 @@
+import { createCleanKind } from '../kind.mjs';
+import { constrainedTypeKind } from './base.mjs';
+import { kindHeritage } from '../../common/kind.mjs';
+import { flatMap } from '../../array/flatMap.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+import { pipe } from '../../common/pipe.mjs';
+import { map } from '../../array/map.mjs';
+import { entry } from '../../object/entry.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+import { createOverride } from '../../common/override.mjs';
+import { isLeft } from '../../either/left/is.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+import { left } from '../../either/left/create.mjs';
+import { right } from '../../either/right/create.mjs';
+import { wrapValue } from '../../common/wrapValue.mjs';
+
+const constraintsSetHandlerKind = createCleanKind("constraints-set-handler");
+class CreateConstraintsSetError extends kindHeritage("create-constraint-set-error", createErrorKind("create-constraint-set-error"), Error) {
+    data;
+    dataParserError;
+    constructor(data, dataParserError) {
+        super({}, ["Error when create constrained type with set."]);
+        this.data = data;
+        this.dataParserError = dataParserError;
+    }
+}
+/**
+ * {@include clean/createConstraintsSet/index.md}
+ */
+function createConstraintsSet(primitiveHandler, constraint) {
+    const constraints = coalescing(constraint);
+    const checkers = flatMap(constraints, ({ checkers }) => checkers);
+    const dataParserWithCheckers = primitiveHandler
+        .dataParser
+        .addChecker(...checkers);
+    const constraintKindValue = pipe(constraints, map(({ name }) => entry(name, null)), fromEntries);
+    const wrappedConstraints = pipe(constraints, map((constrain) => entry(constrain.name, constrain)), fromEntries);
+    function getConstraint(name) {
+        return wrappedConstraints[name];
+    }
+    function create(data) {
+        const result = dataParserWithCheckers.parse(unwrap(data));
+        if (isLeft(result)) {
+            return left("createConstraintsSetError", unwrap(result));
+        }
+        else if (constrainedTypeKind.has(data)) {
+            return right("createConstraintsSet", constrainedTypeKind.addTo(data, {
+                ...constrainedTypeKind.getValue(data),
+                ...constraintKindValue,
+            }));
+        }
+        else {
+            return right("createConstraintsSet", constrainedTypeKind.setTo(wrapValue(unwrap(result)), constraintKindValue));
+        }
+    }
+    function createOrThrow(data) {
+        const result = create(data);
+        if (isLeft(result)) {
+            throw new CreateConstraintsSetError(data, unwrap(result));
+        }
+        else {
+            return unwrap(result);
+        }
+    }
+    function is(input) {
+        if (!constrainedTypeKind.has(input)) {
+            return false;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-for-of
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return pipe({
+        primitiveHandler,
+        constrains: constraints,
+        getConstraint,
+        create,
+        createOrThrow,
+        createWithUnknown: create,
+        createWithUnknownOrThrow: createOrThrow,
+        is,
+    }, constraintsSetHandlerKind.setTo, createConstraintsSet.overrideHandler.apply);
+}
+createConstraintsSet.overrideHandler = createOverride("@duplojs/utils/clean/constraints-set");
+
+export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet };