@strictly/define 0.0.12 → 0.0.14

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { IsEqual, Simplify, UnionToIntersection, SimplifyDeep } from 'type-fest';
-import { IsFieldReadonly } from '@strictly/base';
+import { IsFieldReadonly, StringConcatOf } from '@strictly/base';
 
 type Type<T extends TypeDef = TypeDef> = {
     readonly definition: T;
@@ -198,50 +198,75 @@ declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<
 
 declare function flattenTypesOfType<T extends StrictType>(t: T): Record<string, Type>;
 
+type Annotations = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
+type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
+    readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
+    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
+};
+type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
+type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
+type ValidationError<Type extends string, Data = {}> = Simplify<{
+    type: Type;
+} & Data>;
+declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
+declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
+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;
+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>;
+declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
+declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
+    readonly: boolean;
+    required: boolean;
+};
+
 type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
     readonly definition: T;
 };
-type Rule<E = any, V = any> = (v: V) => E | null;
 type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never;
-type ValidatingTypeDef<E = any> = ValidatingLiteralTypeDef<E> | ValidatingListTypeDef<E> | ValidatingRecordTypeDef<E> | ValidatingObjectTypeDef<E> | ValidatingUnionTypeDef<E>;
+type ContextOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer _E, infer C> ? C : never;
+type Rule<E, C, V = any> = FunctionalValidator<V, E, string, C>;
+type ValidatingTypeDef<E = any, C = any> = ValidatingLiteralTypeDef<E, C> | ValidatingListTypeDef<E, C> | ValidatingRecordTypeDef<E, C> | ValidatingObjectTypeDef<E, C> | ValidatingUnionTypeDef<E, C>;
 type AnyTypeDef = any;
-type ValidatingLiteralTypeDef<E = any, V = any> = {
+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;
 };
-type ValidatingListTypeDef<E = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
+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;
 };
-type ValidatingRecordTypeDef<E = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
+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;
 };
 type ValidatingObjectTypeDefFields = {
     [Key: ObjectFieldKey]: AnyTypeDef;
 };
-type ValidatingObjectTypeDef<E = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
+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;
 };
-type ValidatingUnionTypeDef<E = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
+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;
 };
@@ -254,52 +279,32 @@ 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>;
 }[keyof Unions]> : never : never;
 
-type Annotations = {
-    readonly required: boolean;
-    readonly readonly: boolean;
-};
-type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
-type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
-    readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
-    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
-};
-type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
-type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
-type ValidationError<Type extends string, Data = {}> = Simplify<{
-    type: Type;
-} & Data>;
-declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
-declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
-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;
-declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
-declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
-    readonly: boolean;
-    required: boolean;
-};
-
-type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string, Context> = T extends ValidatingTypeDef<infer E> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, Context> : never;
-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>;
-};
+type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string> = T extends ValidatingTypeDef<infer E, infer C> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, C> : never;
+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]>;
+}>;
 
 declare function flattenValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfValidatingType<T, '*'>>(type: T): FlattenedValidatorsOfValidatingType<T, TypePathsToValuePaths, FlattenedTypes>;
 
 declare function flattenValuesOfType<T extends Type>(typeDef: Type, value: ValueOfType<T>): Readonly<Record<string, any>>;
 
-declare function jsonPath(prefix: string, segment: number | string, qualifier?: string): string;
-declare function jsonPathPop(path: string): [string, string] | null;
+declare function jsonPath<Prefix extends string, Segment extends number | string>(prefix: Prefix, segment: Segment): `${Prefix}.${Segment}`;
+declare function jsonPath<Prefix extends string, Segment extends number | string, Qualifier extends string>(prefix: Prefix, segment: Segment, qualifier: Qualifier): `${Prefix}.${Qualifier}${Segment}`;
+declare function jsonPathPop<Path extends string>(path: Path): [string, string] | null;
+declare function jsonPathPrefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<'$', infer ToMount> ? `${Prefix}${ToMount}` : never;
+declare function jsonPathUnprefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<Prefix, infer ToUnmount> ? `$${ToUnmount}` : never;
 
 declare function valuePathToTypePath<ValuePathsToTypePaths extends Record<string, string>, ValuePath extends keyof ValuePathsToTypePaths>({ definition: typeDef }: Type, valuePath: ValuePath, allowMissingPaths?: boolean): ValuePathsToTypePaths[ValuePath];
 
@@ -349,54 +354,54 @@ type TypeDefOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infe
     };
 } : never;
 
-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> ? {
+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;
@@ -404,7 +409,8 @@ type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T e
 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>>;
@@ -444,29 +450,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>;
 }
-declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>>;
-declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, string>>;
-declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, number>>;
-declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, boolean>>;
-declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, null>>;
-declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, null, {
+declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, T>>;
+declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, string>>;
+declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, number>>;
+declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, boolean>>;
+declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, null>>;
+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>;
 }>;
 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;
 }>;
@@ -474,13 +480,13 @@ declare function record<V extends ValidatingType, K extends RecordKeyType>({ def
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V["definition"];
-    readonly rule: Rule<never>;
+    readonly rule: Rule<never, {}>;
     readonly readonly: boolean;
     readonly required: boolean;
 }>;
 declare function object(): ObjectTypeDefBuilder<never, {}>;
-declare function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>;
-declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>;
+declare function union<D extends null>(): UnionTypeDefBuilder<never, {}, D, {}>;
+declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, {}, D, {}>;
 
 type PathsOfType<T extends Type, SegmentOverride extends string | null = null, Prefix extends string = '$'> = InternalJsonPathsOf<T['definition'], Prefix, SegmentOverride, StartingDepth>;
 type InternalJsonPathsOf<F extends TypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number, NextDepth extends number = Depths[Depth]> = InternalJsonPathsOfChildren<F, Prefix, SegmentOverride, '', NextDepth> | Prefix;
@@ -592,4 +598,4 @@ type ValidatorsOfValues<FlattenedValues extends Readonly<Record<string, any>>, T
     readonly [K in keyof FlattenedValues]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>;
 };
 
-export { type Accessor, type AnnotatedValidator, type Annotations, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, OptionalValidatorProxy, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type RegexpValidationError, RegexpValidationErrorType, RegexpValidator, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, list, literal, mergeAnnotations, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };
+export { type Accessor, type AnnotatedValidator, type Annotations, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, OptionalValidatorProxy, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type RegexpValidationError, RegexpValidationErrorType, RegexpValidator, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, jsonPathPrefix, jsonPathUnprefix, list, literal, mergeAnnotations, mergeValidators, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };

package/dist/index.js

@@ -185,8 +185,12 @@ import {
 } from "@strictly/base";
 
 // transformers/flatteners/json_path.ts
-function jsonPath(prefix, segment, qualifier = "") {
-  const s = `.${qualifier}${segment}`;
+import {
+  assertEqual,
+  assertState
+} from "@strictly/base";
+function jsonPath(prefix, segment, qualifier) {
+  const s = `.${qualifier != null ? qualifier : ""}${segment}`;
   return `${prefix}${s}`;
 }
 function jsonPathPop(path) {
@@ -199,6 +203,14 @@ function jsonPathPop(path) {
     parts.pop()
   ];
 }
+function jsonPathPrefix(prefix, path) {
+  assertEqual(path[0], "$", "{} should start with $", path);
+  return `${prefix}${path.slice(1)}`;
+}
+function jsonPathUnprefix(prefix, path) {
+  assertState(path.startsWith(prefix), "{} should start with {}", path, prefix);
+  return `$${path.slice(prefix.length)}`;
+}
 
 // transformers/flatteners/flatten_value_to.ts
 function flattenValueTo({ definition }, v, setter, mapper2) {
@@ -523,7 +535,7 @@ function flattenValuesOfType(typeDef, value) {
 
 // transformers/flatteners/value_path_to_type_path.ts
 import {
-  assertEqual,
+  assertEqual as assertEqual2,
   assertExists,
   assertExistsAndReturn,
   PreconditionFailedError,
@@ -532,7 +544,7 @@ import {
 } from "@strictly/base";
 function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
   const valueSteps = valuePath.split(/\.|\[/g);
-  assertEqual(valueSteps[0], "$");
+  assertEqual2(valueSteps[0], "$");
   const typeSteps = internalJsonValuePathToTypePath(
     typeDef,
     valueSteps.slice(1),
@@ -660,6 +672,40 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// validation/validators/composite_validator.ts
+var CompositeValidator = class {
+  constructor(...validators) {
+    __publicField(this, "validators");
+    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
+    });
+  }
+};
+
 // validation/validator.ts
 function isFunctionalValidator(v) {
   return typeof v === "function";
@@ -674,6 +720,9 @@ function validate(validator, v, valuePath, context) {
     return validator(v, valuePath, context);
   }
 }
+function mergeValidators(v1, v2) {
+  return new CompositeValidator(v1, v2);
+}
 function annotations(validator, valuePath, context) {
   if (isAnnotatedValidator(validator)) {
     return validator.annotations(valuePath, context);
@@ -782,11 +831,11 @@ var TypeDefBuilder = class _TypeDefBuilder {
   enforce(rule) {
     return new _TypeDefBuilder(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      __spreadProps(__spreadValues(__spreadValues({}, this.definition), isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {}), {
+      __spreadProps(__spreadValues(__spreadValues({}, 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 : validate(rule, value, null, null);
+          return (_a = this.definition.rule(value, valuePath, context)) != null ? _a : rule && validate(rule, value, valuePath, context);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       })
@@ -850,8 +899,9 @@ var ObjectTypeDefBuilder = class _ObjectTypeDefBuilder extends TypeDefBuilder {
       fields: __spreadProps(__spreadValues({}, this.definition.fields), {
         [name]: __spreadProps(__spreadValues({}, definition), {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          rule: function(v) {
-            return definition.rule(v) || (rule == null ? void 0 : rule(v));
+          rule: function(v, valuePath, context) {
+            var _a;
+            return (_a = definition.rule(v, valuePath, context)) != null ? _a : rule && validate(rule, v, valuePath, context);
           }
         })
       })
@@ -1107,9 +1157,12 @@ export {
   isFunctionalValidator,
   jsonPath,
   jsonPathPop,
+  jsonPathPrefix,
+  jsonPathUnprefix,
   list,
   literal,
   mergeAnnotations,
+  mergeValidators,
   mobxCopy,
   nullType,
   nullable,

package/package.json

@@ -35,7 +35,7 @@
     "test:watch": "vitest"
   },
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "exports": {
     ".": {
       "import": {

package/transformers/flatteners/json_path.ts

@@ -1,9 +1,30 @@
-export function jsonPath(prefix: string, segment: number | string, qualifier: string = ''): string {
-  const s = `.${qualifier}${segment}`
-  return `${prefix}${s}`
+import {
+  assertEqual,
+  assertState,
+  type StringConcatOf,
+} from '@strictly/base'
+
+export function jsonPath<
+  Prefix extends string,
+  Segment extends number | string,
+>(prefix: Prefix, segment: Segment): `${Prefix}.${Segment}`
+export function jsonPath<
+  Prefix extends string,
+  Segment extends number | string,
+  Qualifier extends string,
+>(prefix: Prefix, segment: Segment, qualifier: Qualifier): `${Prefix}.${Qualifier}${Segment}`
+export function jsonPath<
+  Prefix extends string,
+  Segment extends number | string,
+  Qualifier extends string = '',
+>(prefix: Prefix, segment: Segment, qualifier?: Qualifier) {
+  const s = `.${qualifier ?? ''}${segment}`
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return `${prefix}${s}` as `${Prefix}.${Qualifier}${Segment}`
 }
 
-export function jsonPathPop(path: string): [string, string] | null {
+// TODO type safety
+export function jsonPathPop<Path extends string>(path: Path): [string, string] | null {
   const parts = path.split('.')
   if (parts.length <= 1) {
     return null
@@ -13,3 +34,22 @@ export function jsonPathPop(path: string): [string, string] | null {
     parts.pop()!,
   ]
 }
+
+export function jsonPathPrefix<
+  Prefix extends string,
+  Path extends string,
+>(prefix: Prefix, path: Path): Path extends StringConcatOf<'$', infer ToMount> ? `${Prefix}${ToMount}` : never {
+  assertEqual(path[0], '$', '{} should start with $', path)
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return `${prefix}${path.slice(1)}` as Path extends StringConcatOf<'$', infer ToMount> ? `${Prefix}${ToMount}` : never
+}
+
+export function jsonPathUnprefix<
+  Prefix extends string,
+  Path extends string,
+>(prefix: Prefix, path: Path): Path extends StringConcatOf<Prefix, infer ToUnmount> ? `$${ToUnmount}` : never {
+  assertState(path.startsWith(prefix), '{} should start with {}', path, prefix)
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return `$${path.slice(prefix.length)}` as Path extends StringConcatOf<Prefix, infer ToUnmount> ? `$${ToUnmount}`
+    : never
+}

package/transformers/flatteners/specs/json_paths.tests.ts

@@ -0,0 +1,69 @@
+import {
+  jsonPath,
+  jsonPathPrefix,
+  jsonPathUnprefix,
+} from 'transformers/flatteners/json_path'
+
+describe('json_paths', () => {
+  describe('jsonPath', () => {
+    describe('simple', () => {
+      const path = jsonPath('$', 'thing')
+
+      it('has the expected type', () => {
+        expectTypeOf(path).toEqualTypeOf<'$.thing'>()
+      })
+
+      it('has the expected value', () => {
+        expect(path).toEqual('$.thing')
+      })
+    })
+
+    describe('indexed', () => {
+      const path = jsonPath<`$.${number}`, number>(`$.${1}`, 1)
+
+      it('has the expected type', () => {
+        expectTypeOf(path).toEqualTypeOf<`$.${number}.${number}`>()
+      })
+
+      it('has the expected value', () => {
+        expect(path).toEqual('$.1.1')
+      })
+    })
+
+    describe('qualified', () => {
+      const path = jsonPath('$', 'x', 'y:')
+
+      it('has the expected type', () => {
+        expectTypeOf(path).toEqualTypeOf<'$.y:x'>()
+      })
+
+      it('has the expected value', () => {
+        expect(path).toEqual('$.y:x')
+      })
+    })
+  })
+
+  describe('jsonPathPrefix', () => {
+    const path = jsonPathPrefix('$.x', '$.x.y')
+
+    it('has the expected type', () => {
+      expectTypeOf(path).toEqualTypeOf<'$.x.x.y'>()
+    })
+
+    it('has the expected value', () => {
+      expect(path).toEqual('$.x.x.y')
+    })
+  })
+
+  describe('jsonPathUnprefix', () => {
+    const path = jsonPathUnprefix('$.x.x.x', '$.x.x.x.x.y')
+
+    it('has the expected type', () => {
+      expectTypeOf(path).toEqualTypeOf<'$.x.y'>()
+    })
+
+    it('has the expected value', () => {
+      expect(path).toEqual('$.x.y')
+    })
+  })
+})