@strictly/define 0.0.12 → 0.0.14

package/.out/types/builders.d.ts

@@ -8,7 +8,8 @@ import { type ValueOfType, type ValueOfTypeDef } from './value_of_type';
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);
-    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    enforce<E2, C2>(): TypeDefBuilder<ValidatingTypeDefWithError<T, E2, C2>>;
+    enforce<E2, C2>(rule: Validator<ValueOfType<Type<T>>, E2, string, C2>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2, C2>>;
     required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
@@ -48,29 +49,29 @@ declare class RecordTypeDefBuilder<T extends ValidatingRecordTypeDef> extends Ty
         readonly readonly: boolean;
     }>;
 }
-declare class ObjectTypeDefBuilder<E, Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {}> extends TypeDefBuilder<ValidatingObjectTypeDef<E, Fields>> {
-    field<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Record<Name, T>>;
-    field<Name extends string, T extends ValidatingTypeDef, RequiredError>(name: Name, { definition }: Type<T>, rule: Rule<RequiredError, ValueOfTypeDef<T>>): ObjectTypeDefBuilder<E, Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>>;
-    readonlyField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Readonly<Record<Name, T>>>;
-    optionalField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Partial<Record<Name, T>>>;
-    readonlyOptionalField<Name extends string, T extends TypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Partial<Readonly<Record<Name, T>>>>;
+declare class ObjectTypeDefBuilder<E, C, Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {}> extends TypeDefBuilder<ValidatingObjectTypeDef<E, C, Fields>> {
+    field<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Record<Name, T>>;
+    field<Name extends string, T extends ValidatingTypeDef, RequiredError, C2>(name: Name, { definition }: Type<T>, rule: Rule<RequiredError, ValueOfTypeDef<T>>): ObjectTypeDefBuilder<E, C & C2, Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C & C2>>>;
+    readonlyField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Readonly<Record<Name, T>>>;
+    optionalField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Partial<Record<Name, T>>>;
+    readonlyOptionalField<Name extends string, T extends TypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Partial<Readonly<Record<Name, T>>>>;
 }
-declare class UnionTypeDefBuilder<E, D extends string | null, U extends Record<UnionKey, TypeDef>> extends TypeDefBuilder<ValidatingUnionTypeDef<E, D, U>> {
-    or<K extends Exclude<UnionKey, keyof U>, T extends TypeDef>(k: K, { definition: typeDef, }: Type<T>): UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U>;
+declare class UnionTypeDefBuilder<E, C, D extends string | null, U extends Record<UnionKey, TypeDef>> extends TypeDefBuilder<ValidatingUnionTypeDef<E, C, D, U>> {
+    or<K extends Exclude<UnionKey, keyof U>, T extends TypeDef>(k: K, { definition: typeDef, }: Type<T>): UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U>;
 }
-export declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>>;
-export declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, string>>;
-export declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, number>>;
-export declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, boolean>>;
-export declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, null>>;
-export declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, null, {
+export declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, T>>;
+export declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, string>>;
+export declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, number>>;
+export declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, boolean>>;
+export declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, null>>;
+export declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, {}, null, {
     readonly ['0']: T;
-    readonly ['1']: ValidatingLiteralTypeDef<never, null>;
+    readonly ['1']: ValidatingLiteralTypeDef<never, {}, null>;
 }>;
 export declare function list<T extends ValidatingTypeDef>(elements: ValidatingType<T>): ListTypeDefBuilder<{
     readonly type: TypeDefType.List;
     elements: T;
-    readonly rule: Rule<never>;
+    readonly rule: Rule<never, {}>;
     readonly readonly: boolean;
     readonly required: boolean;
 }>;
@@ -78,11 +79,11 @@ export declare function record<V extends ValidatingType, K extends RecordKeyType
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V["definition"];
-    readonly rule: Rule<never>;
+    readonly rule: Rule<never, {}>;
     readonly readonly: boolean;
     readonly required: boolean;
 }>;
 export declare function object(): ObjectTypeDefBuilder<never, {}>;
-export declare function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>;
-export declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>;
+export declare function union<D extends null>(): UnionTypeDefBuilder<never, {}, D, {}>;
+export declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, {}, D, {}>;
 export {};

package/.out/types/builders.js

@@ -16,11 +16,13 @@ class TypeDefBuilder {
     enforce(rule) {
         return new TypeDefBuilder(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        Object.assign(Object.assign(Object.assign({}, this.definition), (isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {})), { 
+        Object.assign(Object.assign(Object.assign({}, this.definition), (rule != null && isAnnotatedValidator(rule)
+            ? mergeAnnotations(rule.annotations(null, null), this.definition)
+            : {})), { 
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            rule: (value) => {
+            rule: (value, valuePath, context) => {
                 var _a;
-                return (_a = this.definition.rule(value)) !== null && _a !== void 0 ? _a : validate(rule, value, null, null);
+                return (_a = this.definition.rule(value, valuePath, context)) !== null && _a !== void 0 ? _a : (rule && validate(rule, value, valuePath, context));
             } }));
     }
     required() {
@@ -66,8 +68,9 @@ class ObjectTypeDefBuilder extends TypeDefBuilder {
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             fields: Object.assign(Object.assign({}, this.definition.fields), { [name]: Object.assign(Object.assign({}, definition), { 
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    rule: function (v) {
-                        return definition.rule(v) || (rule === null || rule === void 0 ? void 0 : rule(v));
+                    rule: function (v, valuePath, context) {
+                        var _a;
+                        return (_a = definition.rule(v, valuePath, context)) !== null && _a !== void 0 ? _a : (rule && validate(rule, v, valuePath, context));
                     } }) }) }));
     }
     readonlyField(name, { definition }) {

package/.out/types/flattened_types_of_validating_type.d.ts

@@ -2,7 +2,7 @@ import { type UnionToIntersection } from 'type-fest';
 import { type Type, type TypeDef } from './definitions';
 import { type Depths, type StartingDepth } from './flattened';
 import { type PathOf } from './path_of';
-import { type ErrorOfValidatingTypeDef, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+import { type ContextOfValidatingTypeDef, type ErrorOfValidatingTypeDef, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
 export type FlattenedTypesOfValidatingType<T extends Type, SegmentOverride extends string | null, Path extends string = '$', Depth extends number = StartingDepth> = InternalFlattenedTypeDefsOf<T['definition'], SegmentOverride, Path, '', Depth>;
 type InternalFlattenedTypeDefsOf<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = {
     readonly [K in Path]: Type<T>;
@@ -11,13 +11,13 @@ type InternalFlattenedTypeDefsOfChildren<T extends TypeDef, SegmentOverride exte
 type InternalFlattenedTypeDefsOfLiteralChildren = {};
 type InternalFlattenedTypeDefsOfListChildren<T extends ValidatingListTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['elements'], SegmentOverride, PathOf<Path, number, SegmentOverride>, '', Depth>;
 type InternalFlattenedTypeDefsOfRecordChildren<T extends ValidatingRecordTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['valueTypeDef'], SegmentOverride, PathOf<Path, T['keyPrototype'], SegmentOverride>, '', Depth>;
-type InternalFlattenedTypeDefsOfObjectChildren<T extends ValidatingObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingObjectTypeDef<infer _E, infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
-    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<ValidatingUnionTypeDef<ErrorOfValidatingTypeDef<Exclude<Fields[K], undefined>>, null, {
+type InternalFlattenedTypeDefsOfObjectChildren<T extends ValidatingObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingObjectTypeDef<infer _E, infer _C, infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<ValidatingUnionTypeDef<ErrorOfValidatingTypeDef<Exclude<Fields[K], undefined>>, ContextOfValidatingTypeDef<Exclude<Fields[K], undefined>>, null, {
         readonly '0': Exclude<Fields[K], undefined>;
         readonly '1': ValidatingLiteralTypeDef<undefined>;
     }>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth> : InternalFlattenedTypeDefsOf<Exclude<Fields[K], undefined>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth>;
 }[keyof Fields]> : never : never;
-type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingUnionTypeDef<infer _E, infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
+type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingUnionTypeDef<infer _E, infer _C, infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
     readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, '', Depth>;
 }[keyof Unions]> : UnionToIntersection<{
     readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, `${Qualifier}${K}:`, Depth>;

package/.out/types/flattened_validators_of_validating_type.d.ts

@@ -1,10 +1,11 @@
+import { type Simplify } from 'type-fest';
 import { type Validator } from 'validation/validator';
 import { type FlattenedTypesOfType } from './flattened_types_of_type';
-import { type ReadonlyOfTypeDef, type ReadonlyTypeOfType } from './readonly_type_of_type';
+import { type ReadonlyOfTypeDef } from './readonly_type_of_type';
 import { type ErrorOfValidatingTypeDef, type ValidatingType, type ValidatingTypeDef } from './validating_definitions';
-import { type ValueOfType, type ValueOfTypeDef } from './value_of_type';
-type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string, Context> = T extends ValidatingTypeDef<infer E> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, Context> : never;
-export type FlattenedValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfType<T, '*'>, Context = ValueOfType<ReadonlyTypeOfType<T>>> = {
-    [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]: ValidatorOfValidatingType<FlattenedTypes[K]['definition'], TypePathsToValuePaths[K], Context>;
-};
+import { type ValueOfTypeDef } from './value_of_type';
+type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string> = T extends ValidatingTypeDef<infer E, infer C> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, C> : never;
+export type FlattenedValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfType<T, '*'>> = Simplify<{
+    [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]: ValidatorOfValidatingType<FlattenedTypes[K]['definition'], TypePathsToValuePaths[K]>;
+}>;
 export {};

package/.out/types/specs/flattened_validators_of_validating_type.tests.js

@@ -10,10 +10,10 @@ describe('FlattenedValidatorsOfValidatingType', function () {
     });
     describe('list', function () {
         const literalType = numberType.enforce(function () {
-            return 'x';
+            return 'Y';
         });
         const listType = list(literalType.narrow).enforce(function () {
-            return 'y';
+            return 'X';
         });
         it('equals expected type', function () {
             expectTypeOf().toEqualTypeOf();

package/.out/types/validating_definitions.d.ts

@@ -1,48 +1,50 @@
+import { type FunctionalValidator } from 'validation/validator';
 import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './definitions';
 export type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
     readonly definition: T;
 };
-export type Rule<E = any, V = any> = (v: V) => E | null;
 export type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never;
-export type ValidatingTypeDef<E = any> = ValidatingLiteralTypeDef<E> | ValidatingListTypeDef<E> | ValidatingRecordTypeDef<E> | ValidatingObjectTypeDef<E> | ValidatingUnionTypeDef<E>;
+export type ContextOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer _E, infer C> ? C : never;
+export type Rule<E, C, V = any> = FunctionalValidator<V, E, string, C>;
+export type ValidatingTypeDef<E = any, C = any> = ValidatingLiteralTypeDef<E, C> | ValidatingListTypeDef<E, C> | ValidatingRecordTypeDef<E, C> | ValidatingObjectTypeDef<E, C> | ValidatingUnionTypeDef<E, C>;
 type AnyTypeDef = any;
-export type ValidatingLiteralTypeDef<E = any, V = any> = {
+export type ValidatingLiteralTypeDef<E = any, C = any, V = any> = {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-export type ValidatingListTypeDef<E = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
+export type ValidatingListTypeDef<E = any, C = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
     readonly type: TypeDefType.List;
     readonly elements: Ele;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-export type ValidatingRecordTypeDef<E = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
+export type ValidatingRecordTypeDef<E = any, C = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
 export type ValidatingObjectTypeDefFields = {
     [Key: ObjectFieldKey]: AnyTypeDef;
 };
-export type ValidatingObjectTypeDef<E = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
+export type ValidatingObjectTypeDef<E = any, C = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-export type ValidatingUnionTypeDef<E = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
+export type ValidatingUnionTypeDef<E = any, C = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
     readonly discriminator: D;
     readonly type: TypeDefType.Union;
     readonly unions: U;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };

package/.out/types/validating_type_def_with_error.d.ts

@@ -1,54 +1,54 @@
 import { type IsFieldReadonly } from '@strictly/base';
 import { type TypeDefType } from 'types/definitions';
 import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
-export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E> : never;
-type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2> = T extends ValidatingLiteralTypeDef<infer E1, infer V> ? {
+export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E, C> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E, C> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E, C> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E, C> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E, C> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E, C> : never;
+type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2, C2> = T extends ValidatingLiteralTypeDef<infer E1, infer C1, infer V> ? {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2> = T extends ValidatingListTypeDef<infer E1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2, C2> = T extends ValidatingListTypeDef<infer E1, infer C1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
     readonly type: TypeDefType.List;
     readonly elements: E;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : {
     readonly type: TypeDefType.List;
     elements: E;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T extends ValidatingRecordTypeDef<infer E1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2, C2> = T extends ValidatingRecordTypeDef<infer E1, infer C1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2, C2> = T extends ValidatingObjectTypeDef<infer E1, infer C1, infer Fields> ? {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2, C2> = T extends ValidatingUnionTypeDef<infer E1, infer C1, infer D, infer U> ? {
     readonly type: TypeDefType.Union;
     readonly discriminator: D;
     readonly unions: U;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;

package/.out/validation/validator.d.ts

@@ -16,6 +16,7 @@ export type ValidationError<Type extends string, Data = {}> = Simplify<{
 export declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
 export declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 export declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
+export declare function mergeValidators<V = any, E1 = any, E2 = any, ValuePath extends string = any, C1 = any, C2 = any>(v1: Validator<V, E1, ValuePath, C1>, v2: Validator<V, E2, ValuePath, C2>): Validator<V, E1 | E2, ValuePath, C1 & C2>;
 export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
 export declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
     readonly: boolean;

package/.out/validation/validator.js

@@ -1,3 +1,4 @@
+import { CompositeValidator } from './validators/composite_validator';
 export function isFunctionalValidator(v) {
     return typeof v === 'function';
 }
@@ -12,6 +13,9 @@ export function validate(validator, v, valuePath, context) {
         return validator(v, valuePath, context);
     }
 }
+export function mergeValidators(v1, v2) {
+    return new CompositeValidator(v1, v2);
+}
 export function annotations(validator, valuePath, context) {
     if (isAnnotatedValidator(validator)) {
         return validator.annotations(valuePath, context);

package/.out/validation/validators/composite_validator.d.ts

@@ -0,0 +1,7 @@
+import { type AnnotatedValidator, type Annotations, type Validator } from 'validation/validator';
+export declare class CompositeValidator<V, E, ValuePath extends string, C> implements AnnotatedValidator<V, E, ValuePath, C> {
+    private readonly validators;
+    constructor(...validators: readonly Validator<V, E, ValuePath, C>[]);
+    validate(v: V, valuePath: ValuePath, context: C): E | null;
+    annotations(valuePath: ValuePath, context: C): Annotations;
+}

package/.out/validation/validators/composite_validator.js

@@ -0,0 +1,32 @@
+import { annotations, validate, } from 'validation/validator';
+export class CompositeValidator {
+    constructor(...validators) {
+        Object.defineProperty(this, "validators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.validators = validators;
+    }
+    validate(v, valuePath, context) {
+        return this.validators.reduce((error, validator) => {
+            if (error != null) {
+                return error;
+            }
+            return validate(validator, v, valuePath, context);
+        }, null);
+    }
+    annotations(valuePath, context) {
+        return this.validators.reduce(({ required, readonly, }, validator) => {
+            const { readonly: validatorReadonly, required: validatorRequired, } = annotations(validator, valuePath, context);
+            return {
+                required: required || validatorRequired,
+                readonly: readonly || validatorReadonly,
+            };
+        }, {
+            required: false,
+            readonly: false,
+        });
+    }
+}

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: es6
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 30.58 KB
-CJS ⚡️ Build success in 57ms
-ESM dist/index.js 28.28 KB
-ESM ⚡️ Build success in 58ms
+CJS dist/index.cjs 32.25 KB
+CJS ⚡️ Build success in 66ms
+ESM dist/index.js 29.82 KB
+ESM ⚡️ Build success in 66ms
 DTS Build start
-DTS ⚡️ Build success in 5487ms
-DTS dist/index.d.cts 40.10 KB
-DTS dist/index.d.ts  40.10 KB
-Done in 6.36s.
+DTS ⚡️ Build success in 5471ms
+DTS dist/index.d.cts 41.55 KB
+DTS dist/index.d.ts  41.55 KB
+Done in 6.35s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 4.92s.
+Done in 4.96s.