@strictly/define 0.0.12 → 0.0.14

package/types/builders.ts

@@ -43,15 +43,20 @@ class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
   constructor(readonly definition: T) {
   }
 
-  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>) {
-    return new 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>>
+  enforce<E2, C2>(rule?: Validator<ValueOfType<Type<T>>, E2, string, C2>) {
+    return new TypeDefBuilder<ValidatingTypeDefWithError<T, E2, C2>>(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        ...(isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null!, null!), this.definition) : {}),
+        ...(rule != null && isAnnotatedValidator(rule)
+          ? mergeAnnotations(rule.annotations(null!, null!), this.definition)
+          : {}),
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (value: any) => {
-          return this.definition.rule(value) ?? validate(rule, value, null!, null!)
+        rule: (value: any, valuePath: string, context: any) => {
+          return this.definition.rule(value, valuePath, context) ?? (rule && validate(rule, value, valuePath, context))
         },
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } as any,
@@ -153,12 +158,12 @@ class RecordTypeDefBuilder<T extends ValidatingRecordTypeDef> extends TypeDefBui
     })
   }
 }
-
 class ObjectTypeDefBuilder<
   E,
+  C,
   Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {},
 > extends TypeDefBuilder<
-  ValidatingObjectTypeDef<E, Fields>
+  ValidatingObjectTypeDef<E, C, Fields>
 > {
   field<
     Name extends string,
@@ -168,36 +173,42 @@ class ObjectTypeDefBuilder<
     { 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,
-    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
+    C & C2,
+    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C & C2>>
   >
   field<
     Name extends string,
     T extends ValidatingTypeDef,
     RequiredError = never,
+    C2 = {},
   >(
     name: Name,
     { definition }: Type<T>,
-    rule?: Rule<RequiredError, ValueOfTypeDef<T>>,
+    rule?: Rule<RequiredError, C2, ValueOfTypeDef<T>>,
   ): ObjectTypeDefBuilder<
     E,
-    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
+    C & C2,
+    Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C2>>
   > {
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
       E,
-      Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>
+      C & C2,
+      Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C2>>
     >({
       ...this.definition,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -206,11 +217,11 @@ class ObjectTypeDefBuilder<
         [name]: {
           ...definition,
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          rule: function (v: any) {
-            return definition.rule(v) || rule?.(v)
+          rule: function (v: any, valuePath: string, context: C2) {
+            return definition.rule(v, valuePath, context) ?? (rule && validate(rule, v, valuePath, context))
           },
         },
-      } as Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>,
+      } as Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C2>>,
     })
   }
 
@@ -222,6 +233,7 @@ class ObjectTypeDefBuilder<
     { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
     E,
+    C,
     Fields & Readonly<Record<Name, T>>
   > {
     const newFields = {
@@ -233,6 +245,7 @@ class ObjectTypeDefBuilder<
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
       E,
+      C,
       Fields & Readonly<Record<Name, T>>
     >({
       ...this.definition,
@@ -251,6 +264,7 @@ class ObjectTypeDefBuilder<
     { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
     E,
+    C,
     Fields & Partial<Record<Name, T>>
   > {
     const newFields = {
@@ -261,6 +275,7 @@ class ObjectTypeDefBuilder<
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
       E,
+      C,
       Fields & Partial<Record<Name, T>>
     >({
       ...this.definition,
@@ -279,6 +294,7 @@ class ObjectTypeDefBuilder<
     { definition }: Type<T>,
   ): ObjectTypeDefBuilder<
     E,
+    C,
     Fields & Partial<Readonly<Record<Name, T>>>
   > {
     const newFields = {
@@ -290,6 +306,7 @@ class ObjectTypeDefBuilder<
     // have to explicitly supply types as TS will infinitely recurse trying to infer them!
     return new ObjectTypeDefBuilder<
       E,
+      C,
       Fields & Partial<Readonly<Record<Name, T>>>
     >({
       ...this.definition,
@@ -303,11 +320,13 @@ class ObjectTypeDefBuilder<
 
 class UnionTypeDefBuilder<
   E,
+  C,
   D extends string | null,
   U extends Record<UnionKey, TypeDef>,
 > extends TypeDefBuilder<
   ValidatingUnionTypeDef<
     E,
+    C,
     D,
     U
   >
@@ -320,11 +339,11 @@ class UnionTypeDefBuilder<
     {
       definition: typeDef,
     }: Type<T>,
-  ): UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U> {
+  ): UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U> {
     const {
       unions,
     } = this.definition
-    return new UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U>(
+    return new UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U>(
       {
         ...this.definition,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -337,7 +356,7 @@ class UnionTypeDefBuilder<
   }
 }
 
-export function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>> {
+export function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, T>> {
   return new TypeDefBuilder({
     type: TypeDefType.Literal,
     valuePrototype: value!,
@@ -356,10 +375,11 @@ export function nullable<
   T extends ValidatingTypeDef,
 >(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<
   never,
+  {},
   null,
   {
     readonly ['0']: T,
-    readonly ['1']: ValidatingLiteralTypeDef<never, null>,
+    readonly ['1']: ValidatingLiteralTypeDef<never, {}, null>,
   }
 > {
   return new UnionTypeDefBuilder(
@@ -371,7 +391,7 @@ export function nullable<
         ['1']: nullType.definition,
       },
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      rule: emptyRule as Rule<never>,
+      rule: emptyRule as Rule<never, {}>,
       readonly: false,
       required: false,
     },
@@ -381,12 +401,12 @@ export function nullable<
 export 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,
 }> {
   // have to explicitly supply types as TS will infinitely recurse trying to infer them!
-  return new ListTypeDefBuilder<ValidatingListTypeDef<never, T>>({
+  return new ListTypeDefBuilder<ValidatingListTypeDef<never, {}, T>>({
     type: TypeDefType.List,
     elements: elements.definition,
     rule: emptyRule,
@@ -405,7 +425,7 @@ export function record<
     readonly type: TypeDefType.Record,
     readonly keyPrototype: K,
     valueTypeDef: V['definition'],
-    readonly rule: Rule<never>,
+    readonly rule: Rule<never, {}>,
     readonly readonly: boolean,
     readonly required: boolean,
   }>({
@@ -429,11 +449,11 @@ export function object(): ObjectTypeDefBuilder<never, {}> {
   })
 }
 
-export function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>
-export function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>
-export function union<D extends string | null>(discriminator?: D): UnionTypeDefBuilder<never, D, {}> {
+export function union<D extends null>(): UnionTypeDefBuilder<never, {}, D, {}>
+export function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, {}, D, {}>
+export function union<D extends string | null>(discriminator?: D): UnionTypeDefBuilder<never, {}, D, {}> {
   // have to explicitly supply types as TS will infinitely recurse trying to infer them!
-  return new UnionTypeDefBuilder<never, D, {}>(
+  return new UnionTypeDefBuilder<never, {}, D, {}>(
     {
       type: TypeDefType.Union,
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions

package/types/flattened_types_of_validating_type.ts

@@ -11,6 +11,7 @@ import {
 } from './flattened'
 import { type PathOf } from './path_of'
 import {
+  type ContextOfValidatingTypeDef,
   type ErrorOfValidatingTypeDef,
   type ValidatingListTypeDef,
   type ValidatingLiteralTypeDef,
@@ -93,7 +94,8 @@ type InternalFlattenedTypeDefsOfObjectChildren<
   Path extends string,
   Qualifier extends string,
   Depth extends number,
-> = T extends ValidatingObjectTypeDef<infer _E, infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+> = T extends ValidatingObjectTypeDef<infer _E, infer _C, infer Fields>
+  ? keyof Fields extends string ? UnionToIntersection<{
       readonly [
         K in keyof Fields
       ]-?: undefined extends Fields[K]
@@ -101,6 +103,7 @@ type InternalFlattenedTypeDefsOfObjectChildren<
         ? InternalFlattenedTypeDefsOf<
           ValidatingUnionTypeDef<
             ErrorOfValidatingTypeDef<Exclude<Fields[K], undefined>>,
+            ContextOfValidatingTypeDef<Exclude<Fields[K], undefined>>,
             null,
             {
               readonly '0': Exclude<Fields[K], undefined>,
@@ -129,7 +132,7 @@ type InternalFlattenedTypeDefsOfUnionChildren<
   Path extends string,
   Qualifier extends string,
   Depth extends number,
-> = T extends ValidatingUnionTypeDef<infer _E, infer D, infer Unions>
+> = 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],

package/types/flattened_validators_of_validating_type.ts

@@ -1,8 +1,8 @@
+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 ErrorOfValidatingTypeDef,
@@ -10,24 +10,22 @@ import {
   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>
+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, '*'>,
-  Context = ValueOfType<ReadonlyTypeOfType<T>>,
-> = {
+> // needs to simplify otherwise TS compiler dies
+ = Simplify<{
   [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]:
     ValidatorOfValidatingType<
       FlattenedTypes[K]['definition'],
-      TypePathsToValuePaths[K],
-      Context
+      TypePathsToValuePaths[K]
     >
-}
+}>

package/types/specs/builder.tests.ts

@@ -21,7 +21,7 @@ describe('builder', function () {
       type C = {
         readonly type: TypeDefType.Literal,
         readonly valuePrototype: [number],
-        readonly rule: Rule<never>,
+        readonly rule: Rule<never, {}>,
         readonly required: boolean,
         readonly readonly: boolean,
       }
@@ -49,19 +49,19 @@ describe('builder', function () {
           readonly [0]: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [number],
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           },
           readonly [1]: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [null],
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           },
         },
-        readonly rule: Rule<never>,
+        readonly rule: Rule<never, {}>,
         readonly required: boolean,
         readonly readonly: boolean,
       }
@@ -125,11 +125,11 @@ describe('builder', function () {
             elements: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -147,11 +147,11 @@ describe('builder', function () {
           readonly elements: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [number],
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           },
-          readonly rule: Rule<never>,
+          readonly rule: Rule<never, {}>,
           readonly required: boolean,
           readonly readonly: boolean,
         }
@@ -173,11 +173,11 @@ describe('builder', function () {
             valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -196,11 +196,11 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -218,11 +218,11 @@ describe('builder', function () {
             valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             } | undefined,
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -241,11 +241,11 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             } | undefined,
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -265,11 +265,11 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             } | undefined,
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }
@@ -295,7 +295,7 @@ describe('builder', function () {
             a: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
@@ -304,7 +304,7 @@ describe('builder', function () {
             readonly b: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [boolean],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
@@ -313,7 +313,7 @@ describe('builder', function () {
             c?: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [string],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
@@ -322,12 +322,12 @@ describe('builder', function () {
             readonly d?: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
-              readonly rule: Rule<never>,
+              readonly rule: Rule<never, {}>,
               readonly required: boolean,
               readonly readonly: boolean,
             },
           },
-        readonly rule: Rule<never>,
+        readonly rule: Rule<never, {}>,
         readonly required: boolean,
         readonly readonly: boolean,
       }
@@ -359,7 +359,7 @@ describe('builder', function () {
               readonly [1]: {
                 readonly type: TypeDefType.Literal,
                 readonly valuePrototype: [number],
-                readonly rule: Rule<never>,
+                readonly rule: Rule<never, {}>,
                 readonly required: boolean,
                 readonly readonly: boolean,
               },
@@ -368,12 +368,12 @@ describe('builder', function () {
               readonly [2]: {
                 readonly type: TypeDefType.Literal,
                 readonly valuePrototype: [string],
-                readonly rule: Rule<never>,
+                readonly rule: Rule<never, {}>,
                 readonly required: boolean,
                 readonly readonly: boolean,
               },
             },
-          readonly rule: Rule<never>,
+          readonly rule: Rule<never, {}>,
           readonly required: boolean,
           readonly readonly: boolean,
         }
@@ -407,12 +407,12 @@ describe('builder', function () {
                     a: {
                       readonly type: TypeDefType.Literal,
                       readonly valuePrototype: [boolean],
-                      readonly rule: Rule<never>,
+                      readonly rule: Rule<never, {}>,
                       readonly required: boolean,
                       readonly readonly: boolean,
                     },
                   },
-                  readonly rule: Rule<never>,
+                  readonly rule: Rule<never, {}>,
                   readonly required: boolean,
                   readonly readonly: boolean,
                 },
@@ -424,17 +424,17 @@ describe('builder', function () {
                     b: {
                       readonly type: TypeDefType.Literal,
                       readonly valuePrototype: [number],
-                      readonly rule: Rule<never>,
+                      readonly rule: Rule<never, {}>,
                       readonly required: boolean,
                       readonly readonly: boolean,
                     },
                   },
-                  readonly rule: Rule<never>,
+                  readonly rule: Rule<never, {}>,
                   readonly required: boolean,
                   readonly readonly: boolean,
                 },
               },
-            readonly rule: Rule<never>,
+            readonly rule: Rule<never, {}>,
             readonly required: boolean,
             readonly readonly: boolean,
           }

package/types/specs/flattened_validators_of_validating_type.tests.ts

@@ -9,7 +9,7 @@ import { type Validator } from 'validation/validator'
 
 describe('FlattenedValidatorsOfValidatingType', function () {
   describe('literal', function () {
-    const literalType = numberType.enforce(function (): 'a' {
+    const literalType = numberType.enforce<'a', number>(function (): 'a' {
       return 'a'
     })
     type T = FlattenedValidatorsOfValidatingType<
@@ -27,17 +27,17 @@ describe('FlattenedValidatorsOfValidatingType', function () {
   })
 
   describe('list', function () {
-    const literalType = numberType.enforce(function (): 'x' {
-      return 'x'
+    const literalType = numberType.enforce<'Y', { b: boolean }>(function (): 'Y' {
+      return 'Y'
     })
-    const listType = list(literalType.narrow).enforce(function (): 'y' {
-      return 'y'
+    const listType = list(literalType.narrow).enforce<'X', { a: number }>(function (): 'X' {
+      return 'X'
     })
     type T = FlattenedValidatorsOfValidatingType<typeof listType, Reverse<ValueToTypePathsOfType<typeof listType>>>
 
     type C = {
-      readonly $: Validator<readonly number[], 'y', '$', readonly number[]>,
-      readonly '$.*': Validator<number, 'x', `$.${number}`, readonly number[]>,
+      readonly $: Validator<readonly number[], 'X', '$', { a: number }>,
+      readonly '$.*': Validator<number, 'Y', `$.${number}`, { b: boolean }>,
     }
 
     it('equals expected type', function () {