@duplojs/utils 1.4.51 → 1.4.53

package/dist/clean/entity.cjs

@@ -31,11 +31,12 @@ var otherwise = require('../pattern/otherwise.cjs');
 var justReturn = require('../common/justReturn.cjs');
 var union = require('../dataParser/parsers/union.cjs');
 var minElements = require('../array/minElements.cjs');
+var index$1 = require('../dataParser/parsers/object/index.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 index$1 = require('../dataParser/parsers/object/index.cjs');
 
 const entityKind = kind.createCleanKind("entity");
 const entityHandlerKind = kind.createCleanKind("entity-handler");
@@ -125,7 +126,7 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return entityKind.setTo(updatedEntity, name);
     }
-    return entityHandlerKind.setTo({
+    return pipe.pipe({
         name,
         propertiesDefinition,
         mapDataParser,
@@ -134,8 +135,9 @@ function createEntity(name, getPropertiesDefinition) {
         mapOrThrow,
         is: is$1,
         update,
-    });
+    }, entityHandlerKind.setTo, createEntity.overrideHandler.apply);
 }
+createEntity.overrideHandler = override.createOverride("@duplojs/utils/clean/entity");
 
 exports.CreateEntityError = CreateEntityError;
 exports.createEntity = createEntity;

package/dist/clean/entity.d.ts

@@ -224,5 +224,8 @@ export interface PropertiesDefinitionParams {
  * 
  */
 export declare function createEntity<GenericName extends string, const GenericPropertiesDefinition extends EntityPropertiesDefinition>(name: GenericName, getPropertiesDefinition: (params: PropertiesDefinitionParams) => GenericPropertiesDefinition & DObject.ForbiddenKey<GenericPropertiesDefinition, "_entityName" | "_flags">): EntityHandler<GenericName, GenericPropertiesDefinition>;
+export declare namespace createEntity {
+    var overrideHandler: import("../common").OverrideHandler<EntityHandler<string, Readonly<Record<string, EntityPropertyDefinition>>>>;
+}
 export type GetEntity<GenericEntityHandler extends EntityHandler<string, any>> = Extract<ReturnType<GenericEntityHandler["new"]>, any>;
 export {};

package/dist/clean/entity.mjs

@@ -29,11 +29,12 @@ import { otherwise } from '../pattern/otherwise.mjs';
 import { justReturn } from '../common/justReturn.mjs';
 import { union } from '../dataParser/parsers/union.mjs';
 import { minElements } from '../array/minElements.mjs';
+import { object } from '../dataParser/parsers/object/index.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 { object } from '../dataParser/parsers/object/index.mjs';
 
 const entityKind = createCleanKind("entity");
 const entityHandlerKind = createCleanKind("entity-handler");
@@ -123,7 +124,7 @@ function createEntity(name, getPropertiesDefinition) {
         }
         return entityKind.setTo(updatedEntity, name);
     }
-    return entityHandlerKind.setTo({
+    return pipe({
         name,
         propertiesDefinition,
         mapDataParser,
@@ -132,7 +133,8 @@ function createEntity(name, getPropertiesDefinition) {
         mapOrThrow,
         is,
         update,
-    });
+    }, entityHandlerKind.setTo, createEntity.overrideHandler.apply);
 }
+createEntity.overrideHandler = createOverride("@duplojs/utils/clean/entity");
 
 export { CreateEntityError, createEntity, entityKind };

package/dist/clean/flag.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var kind = require('./kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var override = require('../common/override.cjs');
 
 const flagHandlerKind = kind.createCleanKind("flag-handler");
 const flagKind = kind.createCleanKind("flag");
@@ -8,7 +10,7 @@ const flagKind = kind.createCleanKind("flag");
  * {@include clean/createFlag/index.md}
  */
 function createFlag(name) {
-    return flagHandlerKind.setTo({
+    return pipe.pipe({
         name,
         append(entity, value) {
             const flagValue = flagKind.has(entity)
@@ -26,8 +28,9 @@ function createFlag(name) {
             return flagKind.has(entity)
                 && name in flagKind.getValue(entity);
         },
-    });
+    }, flagHandlerKind.setTo, createFlag.overrideHandler.apply);
 }
+createFlag.overrideHandler = override.createOverride("@duplojs/utils/clean/flag");
 
 exports.createFlag = createFlag;
 exports.flagKind = flagKind;

package/dist/clean/flag.d.ts

@@ -110,5 +110,8 @@ export declare function createFlag<GenericEntity extends Entity = never, Generic
     IsEqual<GenericEntity, never>,
     IsEqual<GenericName, never>
 ]> extends true ? never : NoInfer<GenericName>): FlagHandler<GenericEntity, GenericName, GenericValue>;
+export declare namespace createFlag {
+    var overrideHandler: import("../common").OverrideHandler<FlagHandler<Entity<string>, string, never>>;
+}
 export type GetFlag<GenericHandler extends FlagHandler<any, any, any>> = Extract<Flag<GenericHandler["name"], ReturnType<GenericHandler["getValue"]>>, any>;
 export {};

package/dist/clean/flag.mjs

@@ -1,4 +1,6 @@
 import { createCleanKind } from './kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { createOverride } from '../common/override.mjs';
 
 const flagHandlerKind = createCleanKind("flag-handler");
 const flagKind = createCleanKind("flag");
@@ -6,7 +8,7 @@ const flagKind = createCleanKind("flag");
  * {@include clean/createFlag/index.md}
  */
 function createFlag(name) {
-    return flagHandlerKind.setTo({
+    return pipe({
         name,
         append(entity, value) {
             const flagValue = flagKind.has(entity)
@@ -24,7 +26,8 @@ function createFlag(name) {
             return flagKind.has(entity)
                 && name in flagKind.getValue(entity);
         },
-    });
+    }, flagHandlerKind.setTo, createFlag.overrideHandler.apply);
 }
+createFlag.overrideHandler = createOverride("@duplojs/utils/clean/flag");
 
 export { createFlag, flagKind };

package/dist/clean/index.cjs

@@ -10,6 +10,7 @@ var unwrapEntity = require('./unwrapEntity.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
+var set = require('./constraint/set.cjs');
 var base$1 = require('./primitive/base.cjs');
 var equal = require('./primitive/operations/equal.cjs');
 var add = require('./primitive/operations/number/add.cjs');
@@ -63,9 +64,16 @@ exports.constraintHandlerKind = base.constraintHandlerKind;
 exports.createConstraint = base.createConstraint;
 exports.Int = number.Int;
 exports.Negative = number.Negative;
+exports.NumberMax = number.NumberMax;
+exports.NumberMin = number.NumberMin;
 exports.Positive = number.Positive;
 exports.Email = string.Email;
+exports.StringMax = string.StringMax;
+exports.StringMin = string.StringMin;
 exports.Url = string.Url;
+exports.CreateConstraintsSetError = set.CreateConstraintsSetError;
+exports.constraintsSetHandlerKind = set.constraintsSetHandlerKind;
+exports.createConstraintsSet = set.createConstraintsSet;
 exports.BigInt = base$1.BigInt;
 exports.Boolean = base$1.Boolean;
 exports.CreatePrimitiveError = base$1.CreatePrimitiveError;

package/dist/clean/index.mjs

@@ -6,8 +6,9 @@ export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.m
 export { createFlag, flagKind } from './flag.mjs';
 export { unwrapEntity } from './unwrapEntity.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
-export { Int, Negative, Positive } from './constraint/defaultConstraint/number.mjs';
-export { Email, Url } from './constraint/defaultConstraint/string.mjs';
+export { Int, Negative, NumberMax, NumberMin, Positive } from './constraint/defaultConstraint/number.mjs';
+export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';
+export { CreateConstraintsSetError, constraintsSetHandlerKind, createConstraintsSet } from './constraint/set.mjs';
 export { BigInt, Boolean, CreatePrimitiveError, Date, Number, String, Time, primitiveHandlerKind } from './primitive/base.mjs';
 export { equal } from './primitive/operations/equal.mjs';
 export { add } from './primitive/operations/number/add.mjs';

package/dist/clean/newType.cjs

@@ -1,7 +1,6 @@
 'use strict';
 
 var kind = require('./kind.cjs');
-var base = require('./constraint/base.cjs');
 var kind$1 = require('../common/kind.cjs');
 var flatMap = require('../array/flatMap.cjs');
 var coalescing = require('../array/coalescing.cjs');
@@ -9,12 +8,14 @@ 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 base = require('./constraint/base.cjs');
 var create$1 = require('../either/right/create.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
-var fromEntries = require('../object/fromEntries.cjs');
 
 const newTypeKind = kind.createCleanKind("new-type");
 const newTypeHandlerKind = kind.createCleanKind("new-type-handler");
@@ -33,12 +34,16 @@ class CreateNewTypeError extends kind$1.kindHeritage("create-new-type-error", er
  * {@include clean/createNewType/index.md}
  */
 function createNewType(name, dataParser, constraint) {
-    const constrains = coalescing.coalescing(constraint ?? []);
-    const checkers = flatMap.flatMap(constrains, ({ checkers }) => checkers);
+    const constraints = coalescing.coalescing(constraint ?? []);
+    const checkers = flatMap.flatMap(constraints, ({ checkers }) => checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
-    const constraintKindValue = pipe.pipe(constrains, map.map(({ name }) => entry.entry(name, null)), fromEntries.fromEntries);
+    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)) {
@@ -69,24 +74,26 @@ function createNewType(name, dataParser, constraint) {
             return false;
         }
         // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let index = 0; index < constrains.length; index++) {
-            if (!constrains[index].is(input)) {
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
                 return false;
             }
         }
         return true;
     }
-    return newTypeHandlerKind.setTo({
+    return pipe.pipe({
         name,
         dataParser: dataParserWithCheckers,
-        constrains,
+        constrains: constraints,
+        getConstraint,
         create: create$2,
         createOrThrow,
         createWithUnknown: create$2,
         createWithUnknownOrThrow: createOrThrow,
         is: is$1,
-    });
+    }, newTypeHandlerKind.setTo, createNewType.overrideHandler.apply);
 }
+createNewType.overrideHandler = override.createOverride("@duplojs/utils/clean/new-type");
 
 exports.CreateNewTypeError = CreateNewTypeError;
 exports.createNewType = createNewType;

package/dist/clean/newType.d.ts

@@ -6,11 +6,11 @@ import * as DArray from "../array";
 import type * as DDataParser from "../dataParser";
 import { type DataParserContainTransform } from "./types";
 export declare const newTypeKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type", string>>;
-type _NewType<GenericName extends string, GenericValue extends unknown, GenericConstrainName extends string> = (Kind<typeof newTypeKind.definition, GenericName> & Kind<typeof constrainedTypeKind.definition, Record<GenericConstrainName, unknown>> & WrappedValue<GenericValue>);
-export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstrainName> {
+type _NewType<GenericName extends string, GenericValue extends unknown, GenericConstraintsName extends string> = (Kind<typeof newTypeKind.definition, GenericName> & Kind<typeof constrainedTypeKind.definition, Record<GenericConstraintsName, unknown>> & WrappedValue<GenericValue>);
+export interface NewType<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsName extends string = never> extends _NewType<GenericName, GenericValue, GenericConstraintsName> {
 }
 export declare const newTypeHandlerKind: import("..").KindHandler<import("..").KindDefinition<"@DuplojsUtilsClean/new-type-handler", unknown>>;
-export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstrainHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
+export interface NewTypeHandler<GenericName extends string = string, GenericValue extends unknown = unknown, GenericConstraintsHandler extends readonly ConstraintHandler[] = readonly []> extends Kind<typeof newTypeHandlerKind.definition> {
     /**
      * The NewType name used as the brand (for example "userId").
      * 
@@ -25,7 +25,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * The list of constraints applied to this NewType.
      * 
      */
-    readonly constrains: GenericConstrainHandler;
+    readonly constrains: GenericConstraintsHandler;
     /**
      * Creates a NewType value and returns an Either.
      * 
@@ -34,8 +34,8 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    create<const GenericData extends GenericValue>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
-    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<const GenericInput extends GenericValue>(data: GenericInput): (DEither.Right<"createNewType", NewType<GenericName, GenericInput, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    create<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (DEither.Right<"createNewType", (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>)> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value and throws on error. Works with raw values or primitives.
      * 
@@ -50,8 +50,8 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstrainHandler[number]["name"]>;
-    createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstrainHandler[number]["name"]>);
+    createOrThrow<const GenericData extends GenericValue>(data: GenericData): NewType<GenericName, GenericData, GenericConstraintsHandler[number]["name"]>;
+    createOrThrow<GenericPrimitive extends Primitive<Extract<GenericValue, EligiblePrimitive>>>(data: GenericPrimitive): (GenericPrimitive & NewType<GenericName, Unwrap<GenericPrimitive>, GenericConstraintsHandler[number]["name"]>);
     /**
      * Creates a NewType value from an unknown input and returns an Either.
      * 
@@ -65,7 +65,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createWithUnknown<GenericData extends unknown>(data: GenericData): (DEither.Right<"createNewType", NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
+    createWithUnknown<GenericInput extends unknown>(data: GenericInput): (DEither.Right<"createNewType", NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>> | DEither.Left<"createNewTypeError", DDataParser.DataParserError>);
     /**
      * Creates a NewType value from an unknown input and throws on error.
      * 
@@ -74,7 +74,7 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    createWithUnknownOrThrow<GenericData extends unknown>(data: GenericData): NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>;
+    createWithUnknownOrThrow<GenericInput extends unknown>(data: GenericInput): NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>;
     /**
      * Checks if a value is a NewType of this handler (type guard).
      * 
@@ -83,7 +83,17 @@ export interface NewTypeHandler<GenericName extends string = string, GenericValu
      * ```
      * 
      */
-    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstrainHandler[number]["name"]>>;
+    is<GenericInput extends WrappedValue>(input: GenericInput): input is Extract<GenericInput, NewType<GenericName, GenericValue, GenericConstraintsHandler[number]["name"]>>;
+    /**
+     * Returns a constraint handler by name from the NewType constraints list.
+     * 
+     * ```ts
+     * const constraint = UserId.getConstraint("positive");
+     * constraint.createOrThrow(1);
+     * ```
+     * 
+     */
+    getConstraint<GenericConstraintName extends GenericConstraintsHandler[number]["name"]>(name: GenericConstraintName): Extract<GenericConstraintsHandler[number], ConstraintHandler<GenericConstraintName>>;
 }
 declare const CreateNewTypeError_base: new (params: {
     "@DuplojsUtilsError/create-new-type-error"?: unknown;
@@ -137,9 +147,12 @@ export declare class CreateNewTypeError extends CreateNewTypeError_base {
  * @namespace C
  * 
  */
-export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstrainHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
+export declare function createNewType<GenericName extends string, GenericDataParser extends DDataParser.DataParser, const GenericConstraintsHandler extends (ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]> | readonly [
     ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>,
     ...ConstraintHandler<string, EligiblePrimitive, readonly DDataParser.DataParserChecker<DDataParser.DataParserCheckerDefinition, DDataParser.Output<GenericDataParser>>[]>[]
-]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstrainHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstrainHandler, readonly []>>>;
+]) = never>(name: GenericName, dataParser: GenericDataParser & DataParserContainTransform<GenericDataParser>, constraint?: GenericConstraintsHandler): NewTypeHandler<GenericName, DeepReadonly<DDataParser.Output<GenericDataParser>>, DArray.ArrayCoalescing<NeverCoalescing<GenericConstraintsHandler, readonly []>>>;
+export declare namespace createNewType {
+    var overrideHandler: import("..").OverrideHandler<NewTypeHandler<string, unknown, readonly []>>;
+}
 export type GetNewType<GenericHandler extends NewTypeHandler<string, unknown, readonly any[]>> = Extract<GenericHandler extends any ? NewType<GenericHandler["name"], DDataParser.Output<GenericHandler["dataParser"]>, GenericHandler["constrains"][number]["name"]> : never, any>;
 export {};

package/dist/clean/newType.mjs

@@ -1,5 +1,4 @@
 import { createCleanKind } from './kind.mjs';
-import { constrainedTypeKind } from './constraint/base.mjs';
 import { kindHeritage } from '../common/kind.mjs';
 import { flatMap } from '../array/flatMap.mjs';
 import { coalescing } from '../array/coalescing.mjs';
@@ -7,12 +6,14 @@ 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 { constrainedTypeKind } from './constraint/base.mjs';
 import { right } from '../either/right/create.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
-import { fromEntries } from '../object/fromEntries.mjs';
 
 const newTypeKind = createCleanKind("new-type");
 const newTypeHandlerKind = createCleanKind("new-type-handler");
@@ -31,12 +32,16 @@ class CreateNewTypeError extends kindHeritage("create-new-type-error", createErr
  * {@include clean/createNewType/index.md}
  */
 function createNewType(name, dataParser, constraint) {
-    const constrains = coalescing(constraint ?? []);
-    const checkers = flatMap(constrains, ({ checkers }) => checkers);
+    const constraints = coalescing(constraint ?? []);
+    const checkers = flatMap(constraints, ({ checkers }) => checkers);
     const dataParserWithCheckers = constraint
         ? dataParser.addChecker(...checkers)
         : dataParser;
-    const constraintKindValue = pipe(constrains, map(({ name }) => entry(name, null)), fromEntries);
+    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)) {
@@ -67,23 +72,25 @@ function createNewType(name, dataParser, constraint) {
             return false;
         }
         // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let index = 0; index < constrains.length; index++) {
-            if (!constrains[index].is(input)) {
+        for (let index = 0; index < constraints.length; index++) {
+            if (!constraints[index].is(input)) {
                 return false;
             }
         }
         return true;
     }
-    return newTypeHandlerKind.setTo({
+    return pipe({
         name,
         dataParser: dataParserWithCheckers,
-        constrains,
+        constrains: constraints,
+        getConstraint,
         create,
         createOrThrow,
         createWithUnknown: create,
         createWithUnknownOrThrow: createOrThrow,
         is,
-    });
+    }, newTypeHandlerKind.setTo, createNewType.overrideHandler.apply);
 }
+createNewType.overrideHandler = createOverride("@duplojs/utils/clean/new-type");
 
 export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind };

package/dist/clean/primitive/base.cjs

@@ -3,12 +3,14 @@
 var kind = require('../kind.cjs');
 var kind$1 = require('../../common/kind.cjs');
 var index = require('../../dataParser/parsers/string/index.cjs');
+var pipe = require('../../common/pipe.cjs');
 var index$1 = require('../../dataParser/parsers/number/index.cjs');
 var index$2 = require('../../dataParser/parsers/bigint/index.cjs');
 var boolean = require('../../dataParser/parsers/boolean.cjs');
 var date = require('../../dataParser/parsers/date.cjs');
 var index$3 = require('../../dataParser/parsers/time/index.cjs');
 var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var override = require('../../common/override.cjs');
 var unwrap = require('../../common/unwrap.cjs');
 var is = require('../../either/right/is.cjs');
 var is$1 = require('../../either/left/is.cjs');
@@ -49,15 +51,16 @@ function createPrimitive(dataParser) {
         const result = dataParser.parse(unwrap.unwrap(input));
         return is.isRight(result);
     }
-    return primitiveHandlerKind.setTo({
+    return pipe.pipe({
         dataParser,
         create: create$2,
         createOrThrow,
         createWithUnknown: create$2,
         createWithUnknownOrThrow: createOrThrow,
         is: is$2,
-    });
+    }, primitiveHandlerKind.setTo, createPrimitive.overrideHandler.apply);
 }
+createPrimitive.overrideHandler = override.createOverride("@duplojs/utils/clean/primitive");
 /**
  * {@include clean/String/index.md}
  */

package/dist/clean/primitive/base.mjs

@@ -1,12 +1,14 @@
 import { createCleanKind } from '../kind.mjs';
 import { kindHeritage } from '../../common/kind.mjs';
 import { string } from '../../dataParser/parsers/string/index.mjs';
+import { pipe } from '../../common/pipe.mjs';
 import { number } from '../../dataParser/parsers/number/index.mjs';
 import { bigint } from '../../dataParser/parsers/bigint/index.mjs';
 import { boolean } from '../../dataParser/parsers/boolean.mjs';
 import { date } from '../../dataParser/parsers/date.mjs';
 import { time } from '../../dataParser/parsers/time/index.mjs';
 import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { unwrap } from '../../common/unwrap.mjs';
 import { isRight } from '../../either/right/is.mjs';
 import { isLeft } from '../../either/left/is.mjs';
@@ -47,15 +49,16 @@ function createPrimitive(dataParser) {
         const result = dataParser.parse(unwrap(input));
         return isRight(result);
     }
-    return primitiveHandlerKind.setTo({
+    return pipe({
         dataParser,
         create,
         createOrThrow,
         createWithUnknown: create,
         createWithUnknownOrThrow: createOrThrow,
         is,
-    });
+    }, primitiveHandlerKind.setTo, createPrimitive.overrideHandler.apply);
 }
+createPrimitive.overrideHandler = createOverride("@duplojs/utils/clean/primitive");
 /**
  * {@include clean/String/index.md}
  */

package/dist/clean/repository.cjs

@@ -1,18 +1,21 @@
 'use strict';
 
 var kind = require('./kind.cjs');
+var pipe = require('../common/pipe.cjs');
+var override = require('../common/override.cjs');
 
 const repositoryHandlerKind = kind.createCleanKind("repository-handler");
 /**
  * {@include clean/createRepository/index.md}
  */
 function createRepository() {
-    return repositoryHandlerKind.setTo({
+    return pipe.pipe({
         createImplementation(implementation) {
             return implementation;
         },
-    });
+    }, repositoryHandlerKind.setTo, createRepository.overrideHandler.apply);
 }
+createRepository.overrideHandler = override.createOverride("@duplojs/utils/clean/repository");
 
 exports.createRepository = createRepository;
 exports.repositoryHandlerKind = repositoryHandlerKind;

package/dist/clean/repository.d.ts

@@ -93,3 +93,6 @@ export interface RepositoryHandler<GenericRepository extends object = object> ex
  * 
  */
 export declare function createRepository<GenericRepository extends object>(): RepositoryHandler<GenericRepository>;
+export declare namespace createRepository {
+    var overrideHandler: import("../common").OverrideHandler<RepositoryHandler<object>>;
+}

package/dist/clean/repository.mjs

@@ -1,15 +1,18 @@
 import { createCleanKind } from './kind.mjs';
+import { pipe } from '../common/pipe.mjs';
+import { createOverride } from '../common/override.mjs';
 
 const repositoryHandlerKind = createCleanKind("repository-handler");
 /**
  * {@include clean/createRepository/index.md}
  */
 function createRepository() {
-    return repositoryHandlerKind.setTo({
+    return pipe({
         createImplementation(implementation) {
             return implementation;
         },
-    });
+    }, repositoryHandlerKind.setTo, createRepository.overrideHandler.apply);
 }
+createRepository.overrideHandler = createOverride("@duplojs/utils/clean/repository");
 
 export { createRepository, repositoryHandlerKind };

package/dist/clean/useCase.cjs

@@ -7,19 +7,24 @@ var entry = require('../object/entry.cjs');
 var uncapitalize = require('../string/uncapitalize.cjs');
 var entries = require('../object/entries.cjs');
 var fromEntries = require('../object/fromEntries.cjs');
+var override = require('../common/override.cjs');
 
 const useCaseHandlerKind = kind.createCleanKind("use-case-handler");
 /**
  * {@include clean/createUseCase/index.md}
  */
 function createUseCase(dependencies, getUseCase) {
-    return useCaseHandlerKind.setTo({
+    return pipe.pipe({
         dependencies,
-        getUseCase: (repositories) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => entry.entry(uncapitalize.uncapitalize(key), useCaseHandlerKind.has(value)
-            ? value.getUseCase(repositories)
-            : repositories[uncapitalize.uncapitalize(key)])), fromEntries.fromEntries)),
-    });
+        getUseCase: (injectedDependencies) => getUseCase(pipe.pipe(dependencies, entries.entries, map.map(([key, value]) => {
+            const formattedKey = uncapitalize.uncapitalize(key);
+            return entry.entry(formattedKey, useCaseHandlerKind.has(value) && !injectedDependencies[formattedKey]
+                ? value.getUseCase(injectedDependencies)
+                : injectedDependencies[formattedKey]);
+        }), fromEntries.fromEntries)),
+    }, useCaseHandlerKind.setTo, createUseCase.overrideHandler.apply);
 }
+createUseCase.overrideHandler = override.createOverride("@duplojs/utils/clean/use-case");
 /**
  * {@include clean/useCaseInstances/index.md}
  */

package/dist/clean/useCase.d.ts

@@ -1,12 +1,12 @@
-import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToIntersection } from "../common";
+import { type ObjectEntry, type Kind, type SimplifyTopLevel, type UnionToIntersection, type Adaptor } from "../common";
 import { type RepositoryHandler } from "./repository";
 export type UseCaseDependencies = Record<string, RepositoryHandler | UseCaseHandler>;
 export type UseCaseDependenciesValue<GenericDependencies extends UseCaseDependencies> = SimplifyTopLevel<{
-    [Prop in keyof GenericDependencies as (Prop extends string ? Uncapitalize<Prop> : Prop)]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    [Prop in keyof GenericDependencies as Uncapitalize<Adaptor<Prop, string>>]: GenericDependencies[Prop] extends RepositoryHandler ? ReturnType<GenericDependencies[Prop]["createImplementation"]> : GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
 }>;
 export type GetAllRepositories<GenericDependenciesValue extends UseCaseDependencies> = GenericDependenciesValue extends any ? ({
     [Prop in keyof GenericDependenciesValue]: (GenericDependenciesValue[Prop] extends RepositoryHandler ? [
-        (Prop extends string ? Uncapitalize<Prop> : Prop),
+        Uncapitalize<Adaptor<Prop, string>>,
         ReturnType<GenericDependenciesValue[Prop]["createImplementation"]>
     ] : GenericDependenciesValue[Prop] extends UseCaseHandler ? GetAllRepositories<GenericDependenciesValue[Prop]["dependencies"]> : never);
 })[keyof GenericDependenciesValue] : never;
@@ -26,9 +26,11 @@ export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies
      * ```
      * 
      */
-    getUseCase(repositories: (GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
-        [Entry in InferredEntriesDependenciesValue as InferredEntriesDependenciesValue[0]]: InferredEntriesDependenciesValue[1];
-    } : never)): GenericUseCase;
+    getUseCase(repositories: ((GetAllRepositories<GenericDependencies> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never) & ({
+        [Prop in keyof GenericDependencies as GenericDependencies[Prop] extends UseCaseHandler ? Uncapitalize<Adaptor<Prop, string>> : never]?: GenericDependencies[Prop] extends UseCaseHandler ? ReturnType<GenericDependencies[Prop]["getUseCase"]> : never;
+    }))): GenericUseCase;
 }
 /**
  * Creates a use case handler with explicit dependencies.
@@ -109,6 +111,9 @@ export interface UseCaseHandler<GenericDependencies extends UseCaseDependencies
  * 
  */
 export declare function createUseCase<const GenericDependencies extends UseCaseDependencies, GenericUseCase extends (input: any) => any>(dependencies: GenericDependencies, getUseCase: (dependenciesValue: UseCaseDependenciesValue<GenericDependencies>) => GenericUseCase): UseCaseHandler<GenericDependencies, GenericUseCase>;
+export declare namespace createUseCase {
+    var overrideHandler: import("../common").OverrideHandler<UseCaseHandler<any, any>>;
+}
 /**
  * Instantiates multiple use cases at once.
  * 
@@ -159,5 +164,7 @@ export declare function createUseCase<const GenericDependencies extends UseCaseD
  * 
  */
 export declare function useCaseInstances<GenericUseCases extends Record<string, UseCaseHandler>>(useCases: GenericUseCases, repositories: SimplifyTopLevel<UnionToIntersection<{
-    [Prop in keyof GenericUseCases]: Parameters<GenericUseCases[Prop]["getUseCase"]>[0];
+    [Prop in keyof GenericUseCases]: GetAllRepositories<GenericUseCases[Prop]["dependencies"]> extends infer InferredEntriesDependenciesValue extends ObjectEntry ? {
+        [Entry in InferredEntriesDependenciesValue as Entry[0]]: Entry[1];
+    } : never;
 }[keyof GenericUseCases]>>): UseCaseDependenciesValue<GenericUseCases>;