@duplojs/utils 1.6.1 → 1.6.3

package/dist/array/types/createTuple.d.ts

@@ -1,2 +1,2 @@
 import { type IsEqual } from "../../common/types/isEqual";
-export type CreateTuple<GenericValue extends unknown, GenericLength extends number, GenericLastTuple extends unknown[] = []> = IsEqual<GenericLength, number> extends true ? GenericValue[] : IsEqual<GenericLength, 0> extends true ? [] : [...GenericLastTuple, GenericValue] extends infer InferredResult extends any[] ? IsEqual<InferredResult["length"], GenericLength> extends true ? InferredResult : IsEqual<InferredResult["length"], 1000> extends true ? [...InferredResult, ...GenericValue[]] : CreateTuple<GenericValue, GenericLength, InferredResult> : never;
+export type CreateTuple<GenericValue extends unknown, GenericLength extends number, GenericLastTuple extends readonly unknown[] = []> = IsEqual<GenericLength, number> extends true ? GenericValue[] : IsEqual<GenericLength, 0> extends true ? [] : [...GenericLastTuple, GenericValue] extends infer InferredResult extends any[] ? IsEqual<InferredResult["length"], GenericLength> extends true ? InferredResult : IsEqual<InferredResult["length"], 1000> extends true ? [...InferredResult, ...GenericValue[]] : CreateTuple<GenericValue, GenericLength, InferredResult> : never;

package/dist/clean/constraint/base.cjs

@@ -33,6 +33,7 @@ function createConstraint(name, primitiveHandler, checker) {
     const dataParserWithCheckers = primitiveHandler
         .dataParser
         .addChecker(...checkers);
+    const constraintKindValue = { [name]: null };
     function create$2(data) {
         const result = dataParserWithCheckers.parse(unwrap.unwrap(data));
         if (is.isLeft(result)) {
@@ -68,6 +69,12 @@ function createConstraint(name, primitiveHandler, checker) {
         name,
         primitiveHandler,
         checkers,
+        internal: {
+            primitiveHandler,
+            dataParser: dataParserWithCheckers,
+            checkers,
+            constraintKindValue,
+        },
         create: create$2,
         createOrThrow,
         createWithUnknown: create$2,

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

@@ -4,7 +4,7 @@ import * as DArray from "../../array";
 import * as DEither from "../../either";
 import type * as DDataParser from "../../dataParser";
 export declare const constrainedTypeKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constrained-type", Record<string, unknown>>>;
-export interface ConstrainedType<GenericName extends string, GenericValue extends unknown> extends Kind<typeof constrainedTypeKind.definition, Record<GenericName, unknown>>, WrappedValue<GenericValue> {
+export interface ConstrainedType<GenericName extends string = string, GenericValue extends unknown = unknown> extends Kind<typeof constrainedTypeKind.definition, Record<GenericName, unknown>>, WrappedValue<GenericValue> {
 }
 export declare const constraintHandlerKind: import("../..").KindHandler<import("../..").KindDefinition<"@DuplojsUtilsClean/constraint-handler", unknown>>;
 export interface ConstraintHandler<GenericName extends string = string, GenericPrimitiveValue extends EligiblePrimitive = EligiblePrimitive, GenericCheckers extends readonly DDataParser.DataParserChecker[] = readonly DDataParser.DataParserChecker[], GenericPrimitiveInput extends unknown = unknown> extends Kind<typeof constraintHandlerKind.definition> {
@@ -14,15 +14,35 @@ export interface ConstraintHandler<GenericName extends string = string, GenericP
      */
     readonly name: GenericName;
     /**
-     * The list of DataParser checkers used to validate the primitive.
-     * 
+     * @deprecated
      */
     readonly checkers: GenericCheckers;
     /**
-     * The primitive handler on which the constraint applies (String, Number, etc.).
-     * 
+     * @deprecated
      */
     readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+    readonly internal: {
+        /**
+         * The DataParser with the constraint checkers applied.
+         * 
+         */
+        readonly dataParser: DDataParser.Contract<GenericPrimitiveValue, unknown>;
+        /**
+         * The primitive handler on which the constraint applies (String, Number, etc.).
+         * 
+         */
+        readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
+        /**
+         * The list of DataParser checkers used to validate the primitive.
+         * 
+         */
+        readonly checkers: GenericCheckers;
+        /**
+         * The constraint kind metadata used to tag constrained values.
+         * 
+         */
+        readonly constraintKindValue: Record<string, null>;
+    };
     /**
      * Creates a constrained value and returns an Either.
      * 
@@ -143,5 +163,5 @@ export declare function createConstraint<GenericName extends string, GenericPrim
 export declare namespace createConstraint {
     var overrideHandler: import("../..").OverrideHandler<ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, unknown>[], 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 type GetConstraint<GenericConstrainHandler extends ConstraintHandler, GenericValue extends DDataParser.InputChecker<GenericConstrainHandler["internal"]["checkers"][number]> = DDataParser.InputChecker<GenericConstrainHandler["internal"]["checkers"][number]>> = Extract<ConstrainedType<GenericConstrainHandler["name"], GenericValue>, any>;
 export {};

package/dist/clean/constraint/base.mjs

@@ -31,6 +31,7 @@ function createConstraint(name, primitiveHandler, checker) {
     const dataParserWithCheckers = primitiveHandler
         .dataParser
         .addChecker(...checkers);
+    const constraintKindValue = { [name]: null };
     function create(data) {
         const result = dataParserWithCheckers.parse(unwrap(data));
         if (isLeft(result)) {
@@ -66,6 +67,12 @@ function createConstraint(name, primitiveHandler, checker) {
         name,
         primitiveHandler,
         checkers,
+        internal: {
+            primitiveHandler,
+            dataParser: dataParserWithCheckers,
+            checkers,
+            constraintKindValue,
+        },
         create,
         createOrThrow,
         createWithUnknown: create,

package/dist/clean/constraint/cast.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var base = require('./base.cjs');
+var coalescing = require('../../array/coalescing.cjs');
+
+function castConstraint(constrainedType, constraintHandler) {
+    const preparedConstraintHandler = coalescing.coalescing(constraintHandler);
+    const newConstraints = {
+        ...base.constrainedTypeKind.getValue(constrainedType),
+    };
+    for (let index = 0; index < preparedConstraintHandler.length; index++) {
+        const constraintHandler = preparedConstraintHandler[index];
+        newConstraints[constraintHandler.name] = null;
+    }
+    return base.constrainedTypeKind.addTo(constrainedType, newConstraints);
+}
+
+exports.castConstraint = castConstraint;

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

@@ -0,0 +1,29 @@
+import { type UnionToIntersection, type SimplifyTopLevel, type NeverCoalescing, type And, type Not, type IsEqual } from "../../common";
+import { type ConstraintHandler, type ConstrainedType, type GetConstraint } from "./base";
+import { type Negative, type NumberMaxHandlerInternal, type NumberMaxInternal, type NumberMinHandlerInternal, type NumberMinInternal, type Positive, type StringMaxHandlerInternal, type StringMaxInternal, type StringMinHandlerInternal, type StringMinInternal } from "./defaultConstraint";
+import { type IsLess, type IsGreater } from "../../number";
+declare const SymbolCastErrorMessage: unique symbol;
+type CastConstraintError<GenericConstrainHandler extends ConstraintHandler, GenericReason extends string> = SimplifyTopLevel<{
+    [SymbolCastErrorMessage]: `The constraint "${GenericConstrainHandler["name"]}" is not applicable: ${GenericReason}.`;
+}>;
+type ForbiddenBadCast<GenericConstrainedType extends ConstrainedType, GenericConstrainHandler extends ConstraintHandler> = ((GenericConstrainHandler extends NumberMinHandlerInternal<infer InferredConstraintValue extends number> ? GenericConstrainedType extends Positive ? IsLess<InferredConstraintValue, 0> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredConstraintValue} is greater than zero`> : GenericConstrainedType extends NumberMinInternal<infer InferredReferenceValue extends number> ? And<[
+    IsLess<InferredConstraintValue, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredConstraintValue} is greater than ${InferredReferenceValue}`> : CastConstraintError<GenericConstrainHandler, "no casting possible with number-min"> : never) | (GenericConstrainHandler extends NumberMaxHandlerInternal<infer InferredConstraintValue extends number> ? GenericConstrainedType extends Negative ? IsGreater<InferredConstraintValue, 0> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredConstraintValue} is less than zero`> : GenericConstrainedType extends NumberMaxInternal<infer InferredReferenceValue extends number> ? And<[
+    IsGreater<InferredConstraintValue, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredConstraintValue} is less than ${InferredReferenceValue}`> : CastConstraintError<GenericConstrainHandler, "no casting possible with number-max"> : never) | (GenericConstrainHandler extends StringMinHandlerInternal<infer InferredConstraintValue extends number> ? GenericConstrainedType extends StringMinInternal<infer InferredReferenceValue extends number> ? And<[
+    IsLess<InferredConstraintValue, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `length constraint ${InferredConstraintValue} is greater than ${InferredReferenceValue}`> : CastConstraintError<GenericConstrainHandler, "no casting possible with string-min"> : never) | (GenericConstrainHandler extends StringMaxHandlerInternal<infer InferredConstraintValue extends number> ? GenericConstrainedType extends StringMaxInternal<infer InferredReferenceValue extends number> ? And<[
+    IsGreater<InferredConstraintValue, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `length constraint ${InferredConstraintValue} is less than ${InferredReferenceValue}`> : CastConstraintError<GenericConstrainHandler, "no casting possible with string-max"> : never) | (GenericConstrainHandler extends typeof Positive ? GenericConstrainedType extends NumberMinInternal<infer InferredReferenceValue extends number> ? And<[
+    IsLess<0, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredReferenceValue} is less than zero`> : CastConstraintError<GenericConstrainHandler, "no casting possible with Positive"> : never) | (GenericConstrainHandler extends typeof Negative ? GenericConstrainedType extends NumberMaxInternal<infer InferredReferenceValue extends number> ? And<[
+    IsGreater<0, InferredReferenceValue>,
+    Not<IsEqual<InferredReferenceValue, number>>
+]> extends true ? never : CastConstraintError<GenericConstrainHandler, `constraint ${InferredReferenceValue} is greater than zero`> : CastConstraintError<GenericConstrainHandler, "no casting possible with negative"> : never) | (GenericConstrainHandler extends (typeof Negative | typeof Positive | StringMaxHandlerInternal | StringMinHandlerInternal | NumberMaxHandlerInternal | NumberMinHandlerInternal) ? never : CastConstraintError<GenericConstrainHandler, "no casting possible">)) extends infer InferredResult ? NeverCoalescing<InferredResult, unknown> : never;
+export declare function castConstraint<GenericConstrainedType extends ConstrainedType, GenericConstrainHandler extends ConstraintHandler>(constrainedType: (GenericConstrainedType & ForbiddenBadCast<GenericConstrainedType, GenericConstrainHandler>), constraintHandler: GenericConstrainHandler | GenericConstrainHandler[]): (GenericConstrainedType & UnionToIntersection<GenericConstrainHandler extends ConstraintHandler ? GetConstraint<GenericConstrainHandler> : never>);
+export {};

package/dist/clean/constraint/cast.mjs

@@ -0,0 +1,16 @@
+import { constrainedTypeKind } from './base.mjs';
+import { coalescing } from '../../array/coalescing.mjs';
+
+function castConstraint(constrainedType, constraintHandler) {
+    const preparedConstraintHandler = coalescing(constraintHandler);
+    const newConstraints = {
+        ...constrainedTypeKind.getValue(constrainedType),
+    };
+    for (let index = 0; index < preparedConstraintHandler.length; index++) {
+        const constraintHandler = preparedConstraintHandler[index];
+        newConstraints[constraintHandler.name] = null;
+    }
+    return constrainedTypeKind.addTo(constrainedType, newConstraints);
+}
+
+export { castConstraint };

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

@@ -13,11 +13,11 @@ const Int = base.createConstraint("int", base$1.Number, int.checkerInt());
 /**
  * {@include clean/Positive/index.md}
  */
-const Positive = base.createConstraint("positive", base$1.Number, min.checkerNumberMin(1));
+const Positive = base.createConstraint("positive", base$1.Number, min.checkerNumberMin(0));
 /**
  * {@include clean/Negative/index.md}
  */
-const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(-1));
+const Negative = base.createConstraint("negative", base$1.Number, max.checkerNumberMax(0));
 /**
  * {@include clean/NumberMin/index.md}
  */
@@ -30,17 +30,9 @@ function NumberMin(value) {
 function NumberMax(value) {
     return base.createConstraint(`number-max-${value}`, base$1.Number, max.checkerNumberMax(value));
 }
-/**
- * {@include clean/PositiveInt/index.md}
- */
-const PositiveInt = base.createConstraint("positive-int", base$1.Number, [
-    int.checkerInt(),
-    min.checkerNumberMin(1),
-]);
 
 exports.Int = Int;
 exports.Negative = Negative;
 exports.NumberMax = NumberMax;
 exports.NumberMin = NumberMin;
 exports.Positive = Positive;
-exports.PositiveInt = PositiveInt;

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

@@ -1,4 +1,4 @@
-import { type GetConstraint } from "../base";
+import { type ConstraintHandler, type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 import { type OnlyLiteralNumber } from "../../../common";
 /**
@@ -28,7 +28,7 @@ import { type OnlyLiteralNumber } from "../../../common";
  * @namespace C
  * 
  */
-export declare const Int: import("..").ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt], never>;
+export declare const Int: ConstraintHandler<"int", number, readonly [DDataParser.DataParserCheckerInt], never>;
 export type Int = GetConstraint<typeof Int>;
 /**
  * Constraint handler that validates strictly positive numbers (>= 1).
@@ -57,7 +57,7 @@ export type Int = GetConstraint<typeof Int>;
  * @namespace C
  * 
  */
-export declare const Positive: import("..").ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin], never>;
+export declare const Positive: ConstraintHandler<"positive", number, readonly [DDataParser.DataParserCheckerNumberMin], never>;
 export type Positive = GetConstraint<typeof Positive>;
 /**
  * Constraint handler that validates strictly negative numbers (<= -1).
@@ -86,8 +86,10 @@ export type Positive = GetConstraint<typeof Positive>;
  * @namespace C
  * 
  */
-export declare const Negative: import("..").ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax], never>;
+export declare const Negative: ConstraintHandler<"negative", number, readonly [DDataParser.DataParserCheckerNumberMax], never>;
 export type Negative = GetConstraint<typeof Negative>;
+export type NumberMinHandlerInternal<GenericValue extends number = number> = Extract<ConstraintHandler<`number-min-${GenericValue}`, number, readonly [DDataParser.DataParserCheckerNumberMin], never>, any>;
+export type NumberMinInternal<GenericValue extends number = number> = GetConstraint<NumberMinHandlerInternal<GenericValue>>;
 /**
  * Constraint factory that validates numbers greater than or equal to a minimum.
  * 
@@ -116,8 +118,10 @@ export type Negative = GetConstraint<typeof Negative>;
  * @namespace C
  * 
  */
-export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMin], never>;
-export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin<GenericValue>>;
+export declare function NumberMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): NumberMinHandlerInternal<GenericValue>;
+export type NumberMin<GenericValue extends number> = GetConstraint<ReturnType<typeof NumberMin<GenericValue>>>;
+export type NumberMaxHandlerInternal<GenericValue extends number = number> = Extract<ConstraintHandler<`number-max-${GenericValue}`, number, readonly [DDataParser.DataParserCheckerNumberMax], never>, any>;
+export type NumberMaxInternal<GenericValue extends number = number> = GetConstraint<NumberMaxHandlerInternal<GenericValue>>;
 /**
  * Constraint factory that validates numbers less than or equal to a maximum.
  * 
@@ -146,34 +150,5 @@ export type NumberMin<GenericValue extends number> = ReturnType<typeof NumberMin
  * @namespace C
  * 
  */
-export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`number-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, number, readonly [DDataParser.DataParserCheckerNumberMax], never>;
-export type NumberMax<GenericValue extends number> = ReturnType<typeof NumberMax<GenericValue>>;
-/**
- * Constraint handler that validates strictly positive integers (>= 1).
- * 
- * **Supported call styles:**
- * - Classic: `PositiveInt.create(value)` -> returns Either
- * 
- * Use it as a reusable rule to validate inputs and to constrain NewTypes to positive integer numbers.
- * 
- * ```ts
- * const result = C.PositiveInt.create(4);
- * 
- * if (E.isRight(result)) {
- * 	// result: E.Right<"createConstrainedType", C.ConstrainedType<"positive-int", 4>>
- * }
- * 
- * const value = C.PositiveInt.createOrThrow(10);
- * // value: C.ConstrainedType<"positive-int", 10>
- * 
- * C.PositiveInt.is(value); // type guard
- * 
- * ```
- * 
- * @see https://utils.duplojs.dev/en/v1/api/clean/constraints
- * 
- * @namespace C
- * 
- */
-export declare const PositiveInt: import("..").ConstraintHandler<"positive-int", number, readonly [DDataParser.DataParserCheckerInt, DDataParser.DataParserCheckerNumberMin], never>;
-export type PositiveInt = GetConstraint<typeof PositiveInt>;
+export declare function NumberMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): NumberMaxHandlerInternal<GenericValue>;
+export type NumberMax<GenericValue extends number> = GetConstraint<ReturnType<typeof NumberMax<GenericValue>>>;

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

@@ -11,11 +11,11 @@ const Int = createConstraint("int", Number, checkerInt());
 /**
  * {@include clean/Positive/index.md}
  */
-const Positive = createConstraint("positive", Number, checkerNumberMin(1));
+const Positive = createConstraint("positive", Number, checkerNumberMin(0));
 /**
  * {@include clean/Negative/index.md}
  */
-const Negative = createConstraint("negative", Number, checkerNumberMax(-1));
+const Negative = createConstraint("negative", Number, checkerNumberMax(0));
 /**
  * {@include clean/NumberMin/index.md}
  */
@@ -28,12 +28,5 @@ function NumberMin(value) {
 function NumberMax(value) {
     return createConstraint(`number-max-${value}`, Number, checkerNumberMax(value));
 }
-/**
- * {@include clean/PositiveInt/index.md}
- */
-const PositiveInt = createConstraint("positive-int", Number, [
-    checkerInt(),
-    checkerNumberMin(1),
-]);
 
-export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt };
+export { Int, Negative, NumberMax, NumberMin, Positive };

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

@@ -1,4 +1,4 @@
-import { type GetConstraint } from "../base";
+import { type ConstraintHandler, type GetConstraint } from "../base";
 import * as DDataParser from "../../../dataParser";
 import { type OnlyLiteralNumber } from "../../../common";
 /**
@@ -28,7 +28,7 @@ import { type OnlyLiteralNumber } from "../../../common";
  * @namespace C
  * 
  */
-export declare const Email: import("..").ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail], never>;
+export declare const Email: ConstraintHandler<"email", string, readonly [DDataParser.DataParserCheckerEmail], never>;
 export type Email = GetConstraint<typeof Email>;
 /**
  * Constraint handler that validates a URL string.
@@ -57,8 +57,10 @@ export type Email = GetConstraint<typeof Email>;
  * @namespace C
  * 
  */
-export declare const Url: import("..").ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl], never>;
+export declare const Url: ConstraintHandler<"url", string, readonly [DDataParser.DataParserCheckerUrl], never>;
 export type Url = GetConstraint<typeof Url>;
+export type StringMinHandlerInternal<GenericValue extends number = number> = Extract<ConstraintHandler<`string-min-${GenericValue}`, string, readonly [DDataParser.DataParserCheckerStringMin], never>, any>;
+export type StringMinInternal<GenericValue extends number = number> = GetConstraint<StringMinHandlerInternal<GenericValue>>;
 /**
  * Constraint factory that validates strings with a minimum length.
  * 
@@ -87,8 +89,10 @@ export type Url = GetConstraint<typeof Url>;
  * @namespace C
  * 
  */
-export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-min-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMin], never>;
+export declare function StringMin<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): StringMinHandlerInternal<GenericValue>;
 export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMin<GenericValue>>>;
+export type StringMaxHandlerInternal<GenericValue extends number = number> = Extract<ConstraintHandler<`string-max-${GenericValue}`, string, readonly [DDataParser.DataParserCheckerStringMax], never>, any>;
+export type StringMaxInternal<GenericValue extends number = number> = GetConstraint<StringMaxHandlerInternal<GenericValue>>;
 /**
  * Constraint factory that validates strings with a maximum length.
  * 
@@ -117,5 +121,5 @@ export type StringMin<GenericValue extends number> = GetConstraint<ReturnType<ty
  * @namespace C
  * 
  */
-export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): import("..").ConstraintHandler<`string-max-${GenericValue & OnlyLiteralNumber<GenericValue>}`, string, readonly [DDataParser.DataParserCheckerStringMax], never>;
+export declare function StringMax<GenericValue extends number>(value: GenericValue & OnlyLiteralNumber<GenericValue>): StringMaxHandlerInternal<GenericValue>;
 export type StringMax<GenericValue extends number> = GetConstraint<ReturnType<typeof StringMax<GenericValue>>>;

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

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

package/dist/clean/constraint/set.cjs

@@ -32,7 +32,7 @@ class CreateConstraintsSetError extends kind$1.kindHeritage("create-constraint-s
  */
 function createConstraintsSet(primitiveHandler, constraint) {
     const constraints = coalescing.coalescing(constraint);
-    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
+    const checkers = flatMap.flatMap(constraints, ({ internal }) => internal.checkers);
     const dataParserWithCheckers = primitiveHandler
         .dataParser
         .addChecker(...checkers);
@@ -80,6 +80,12 @@ function createConstraintsSet(primitiveHandler, constraint) {
     return pipe.pipe({
         primitiveHandler,
         constraints,
+        internal: {
+            primitiveHandler,
+            constraints,
+            constraintKindValue,
+            dataParser: dataParserWithCheckers,
+        },
         getConstraint,
         create: create$2,
         createOrThrow,

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

@@ -7,15 +7,35 @@ 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, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly [], GenericPrimitiveInput extends unknown = unknown> extends Kind<typeof constraintsSetHandlerKind.definition> {
     /**
-     * The primitive handler used to validate and wrap values (e.g. `C.String`, `C.Number`).
-     * 
+     * @deprecated
      */
     readonly primitiveHandler: PrimitiveHandler<GenericPrimitiveValue>;
     /**
-     * The list of constraint handlers applied by this set.
-     * 
+     * @deprecated
      */
     readonly constraints: GenericConstraintsHandler;
+    readonly internal: {
+        /**
+         * The DataParser with all constraint checkers from the set applied.
+         * 
+         */
+        readonly dataParser: DDataParser.Contract<GenericPrimitiveValue, unknown>;
+        /**
+         * 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 constraints: GenericConstraintsHandler;
+        /**
+         * The constraint kind metadata applied by the set.
+         * 
+         */
+        readonly constraintKindValue: Record<string, null>;
+    };
     /**
      * Creates a constrained value and returns an Either.
      * 
@@ -145,5 +165,5 @@ export declare function createConstraintsSet<GenericPrimitiveValue extends Eligi
 export declare namespace createConstraintsSet {
     var overrideHandler: import("../..").OverrideHandler<ConstraintsSetHandler<EligiblePrimitive, readonly [], unknown>>;
 }
-export type GetConstraints<GenericHandler extends ConstraintsSetHandler<EligiblePrimitive, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["constraints"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
+export type GetConstraints<GenericHandler extends ConstraintsSetHandler<EligiblePrimitive, readonly any[]>> = Extract<GenericHandler extends any ? UnionToIntersection<GenericHandler["internal"]["constraints"][number] extends infer InferredConstraint ? InferredConstraint extends ConstraintHandler ? GetConstraint<InferredConstraint> : never : never> : never, any>;
 export {};

package/dist/clean/constraint/set.mjs

@@ -30,7 +30,7 @@ class CreateConstraintsSetError extends kindHeritage("create-constraint-set-erro
  */
 function createConstraintsSet(primitiveHandler, constraint) {
     const constraints = coalescing(constraint);
-    const checkers = flatMap(constraints, ({ checkers }) => checkers);
+    const checkers = flatMap(constraints, ({ internal }) => internal.checkers);
     const dataParserWithCheckers = primitiveHandler
         .dataParser
         .addChecker(...checkers);
@@ -78,6 +78,12 @@ function createConstraintsSet(primitiveHandler, constraint) {
     return pipe({
         primitiveHandler,
         constraints,
+        internal: {
+            primitiveHandler,
+            constraints,
+            constraintKindValue,
+            dataParser: dataParserWithCheckers,
+        },
         getConstraint,
         create,
         createOrThrow,

package/dist/clean/entity/index.cjs

@@ -7,13 +7,13 @@ var kind$1 = require('../../common/kind.cjs');
 var pipe = require('../../common/pipe.cjs');
 var map = require('../../array/map.cjs');
 var entry = require('../../object/entry.cjs');
-var fromEntries = require('../../object/fromEntries.cjs');
+var base = require('../constraint/base.cjs');
 var transform = require('../../dataParser/parsers/transform.cjs');
 var entries = require('../../object/entries.cjs');
 var forward = require('../../common/forward.cjs');
 var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
 var index = require('../../dataParser/parsers/object/index.cjs');
-var base = require('../constraint/base.cjs');
+var fromEntries = require('../../object/fromEntries.cjs');
 var wrapValue = require('../../common/wrapValue.cjs');
 var override = require('../../common/override.cjs');
 var is = require('../../either/left/is.cjs');
@@ -41,8 +41,14 @@ function createEntity(name, getPropertiesDefinition) {
     }
     const propertiesDefinition = getPropertiesDefinition(property.entityPropertyDefinitionTools);
     const mapDataParser = pipe.pipe(forward.forward(propertiesDefinition), entries.entries, map.map(([key, property$1]) => entry.entry(key, property.entityPropertyDefinitionToDataParser(property$1, (newTypeHandler) => {
-        const constraintKindValue = pipe.pipe(newTypeHandler.constraints, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
-        return transform.transform(newTypeHandler.dataParser, (value) => base.constrainedTypeKind.setTo(newType.newTypeKind.setTo(wrapValue.wrapValue(value), newTypeHandler.name), constraintKindValue));
+        const allKind = {
+            ...base.constrainedTypeKind.setTo({}, newTypeHandler.internal.constraintKindValue),
+            ...newType.newTypeKind.setTo({}, newTypeHandler.name),
+        };
+        return transform.transform(newTypeHandler.internal.dataParser, (value) => ({
+            ...allKind,
+            [wrapValue.keyWrappedValue]: value,
+        }));
     }))), fromEntries.fromEntries, index.object, (dataParser) => transform.transform(dataParser, (value) => entityKind.setTo(value, name)));
     function map$1(rawProperties) {
         const result = mapDataParser.parse(rawProperties);
@@ -74,6 +80,9 @@ function createEntity(name, getPropertiesDefinition) {
         name,
         propertiesDefinition,
         mapDataParser,
+        internal: {
+            mapDataParser,
+        },
         new: theNew,
         map: map$1,
         mapOrThrow,
@@ -92,4 +101,5 @@ exports.entityPropertyStructureKind = property.entityPropertyStructureKind;
 exports.entityPropertyUnionKind = property.entityPropertyUnionKind;
 exports.CreateEntityError = CreateEntityError;
 exports.createEntity = createEntity;
+exports.entityHandlerKind = entityHandlerKind;
 exports.entityKind = entityKind;

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

@@ -18,7 +18,7 @@ export type PropertiesToMapOfEntity<GenericPropertiesDefinition extends EntityPr
 export declare const entityKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity", string>>;
 export interface Entity<GenericName extends string = string> extends Kind<typeof entityKind.definition, GenericName> {
 }
-declare const entityHandlerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-handler", unknown>>;
+export declare const entityHandlerKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsClean/entity-handler", unknown>>;
 export interface EntityHandler<GenericName extends string = string, GenericPropertiesDefinition extends EntityPropertiesDefinition = EntityPropertiesDefinition> extends Kind<typeof entityHandlerKind.definition> {
     /**
      * The entity name used as a runtime identifier (for example "User").
@@ -30,7 +30,17 @@ export interface EntityHandler<GenericName extends string = string, GenericPrope
      * 
      */
     readonly propertiesDefinition: GenericPropertiesDefinition;
+    /**
+     * @deprecated
+     */
     readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, unknown>;
+    readonly internal: {
+        /**
+         * The DataParser used internally to map raw properties into an entity.
+         * 
+         */
+        readonly mapDataParser: DDataParser.Contract<EntityProperties<GenericPropertiesDefinition>, unknown>;
+    };
     /**
      * Builds an entity from already typed properties.
      * 

package/dist/clean/entity/index.mjs

@@ -6,14 +6,14 @@ import { kindHeritage } from '../../common/kind.mjs';
 import { pipe } from '../../common/pipe.mjs';
 import { map } from '../../array/map.mjs';
 import { entry } from '../../object/entry.mjs';
-import { fromEntries } from '../../object/fromEntries.mjs';
+import { constrainedTypeKind } from '../constraint/base.mjs';
 import { transform } from '../../dataParser/parsers/transform.mjs';
 import { entries } from '../../object/entries.mjs';
 import { forward } from '../../common/forward.mjs';
 import { createErrorKind } from '../../common/errorKindNamespace.mjs';
 import { object } from '../../dataParser/parsers/object/index.mjs';
-import { constrainedTypeKind } from '../constraint/base.mjs';
-import { wrapValue } from '../../common/wrapValue.mjs';
+import { fromEntries } from '../../object/fromEntries.mjs';
+import { keyWrappedValue } from '../../common/wrapValue.mjs';
 import { createOverride } from '../../common/override.mjs';
 import { isLeft } from '../../either/left/is.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
@@ -40,8 +40,14 @@ function createEntity(name, getPropertiesDefinition) {
     }
     const propertiesDefinition = getPropertiesDefinition(entityPropertyDefinitionTools);
     const mapDataParser = pipe(forward(propertiesDefinition), entries, map(([key, property]) => entry(key, entityPropertyDefinitionToDataParser(property, (newTypeHandler) => {
-        const constraintKindValue = pipe(newTypeHandler.constraints, map(({ name }) => entry(name, null)), fromEntries);
-        return transform(newTypeHandler.dataParser, (value) => constrainedTypeKind.setTo(newTypeKind.setTo(wrapValue(value), newTypeHandler.name), constraintKindValue));
+        const allKind = {
+            ...constrainedTypeKind.setTo({}, newTypeHandler.internal.constraintKindValue),
+            ...newTypeKind.setTo({}, newTypeHandler.name),
+        };
+        return transform(newTypeHandler.internal.dataParser, (value) => ({
+            ...allKind,
+            [keyWrappedValue]: value,
+        }));
     }))), fromEntries, object, (dataParser) => transform(dataParser, (value) => entityKind.setTo(value, name)));
     function map$1(rawProperties) {
         const result = mapDataParser.parse(rawProperties);
@@ -73,6 +79,9 @@ function createEntity(name, getPropertiesDefinition) {
         name,
         propertiesDefinition,
         mapDataParser,
+        internal: {
+            mapDataParser,
+        },
         new: theNew,
         map: map$1,
         mapOrThrow,
@@ -82,4 +91,4 @@ function createEntity(name, getPropertiesDefinition) {
 }
 createEntity.overrideHandler = createOverride("@duplojs/utils/clean/entity");
 
-export { CreateEntityError, createEntity, entityKind, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools };
+export { CreateEntityError, createEntity, entityHandlerKind, entityKind, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools };

package/dist/clean/index.cjs

@@ -7,9 +7,11 @@ var repository = require('./repository.cjs');
 var useCase = require('./useCase.cjs');
 var flag = require('./flag.cjs');
 var maybe = require('./maybe.cjs');
+var toMapDataParser = require('./toMapDataParser.cjs');
 var property = require('./entity/property.cjs');
 var unwrap = require('./entity/unwrap.cjs');
 var base = require('./constraint/base.cjs');
+var cast = require('./constraint/cast.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
 var time = require('./constraint/defaultConstraint/time.cjs');
@@ -52,6 +54,7 @@ exports.newTypeHandlerKind = newType.newTypeHandlerKind;
 exports.newTypeKind = newType.newTypeKind;
 exports.CreateEntityError = index.CreateEntityError;
 exports.createEntity = index.createEntity;
+exports.entityHandlerKind = index.entityHandlerKind;
 exports.entityKind = index.entityKind;
 exports.createRepository = repository.createRepository;
 exports.repositoryHandlerKind = repository.repositoryHandlerKind;
@@ -62,6 +65,7 @@ exports.createFlag = flag.createFlag;
 exports.flagKind = flag.flagKind;
 exports.none = maybe.none;
 exports.some = maybe.some;
+exports.toMapDataParser = toMapDataParser.toMapDataParser;
 exports.entityPropertyArrayKind = property.entityPropertyArrayKind;
 exports.entityPropertyDefinitionToDataParser = property.entityPropertyDefinitionToDataParser;
 exports.entityPropertyDefinitionTools = property.entityPropertyDefinitionTools;
@@ -75,12 +79,12 @@ exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
 exports.constrainedTypeKind = base.constrainedTypeKind;
 exports.constraintHandlerKind = base.constraintHandlerKind;
 exports.createConstraint = base.createConstraint;
+exports.castConstraint = cast.castConstraint;
 exports.Int = number.Int;
 exports.Negative = number.Negative;
 exports.NumberMax = number.NumberMax;
 exports.NumberMin = number.NumberMin;
 exports.Positive = number.Positive;
-exports.PositiveInt = number.PositiveInt;
 exports.Email = string.Email;
 exports.StringMax = string.StringMax;
 exports.StringMin = string.StringMin;