@strictly/define 0.0.1 → 0.0.2

package/types/flattened_types_of_validating_type.ts

@@ -0,0 +1,152 @@
+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'
+
+// TODO rename to FlattenedValidatingTypesOfValidatingType
+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>
+  }
+  & InternalFlattenedTypeDefsOfChildren<T, SegmentOverride, Path, Qualifier, Depth>
+
+type InternalFlattenedTypeDefsOfChildren<
+  T extends TypeDef,
+  SegmentOverride extends string | null,
+  Path extends string,
+  Qualifier extends string,
+  Depth extends number,
+  NextDepth extends number = Depths[Depth],
+> =
+  // resolve anything too deep to `never` instead of to {} so the caller knows
+  // it has explicitly failed
+  NextDepth extends -1 ? never
+    : T extends ValidatingLiteralTypeDef ? InternalFlattenedTypeDefsOfLiteralChildren
+    : T extends ValidatingListTypeDef ? InternalFlattenedTypeDefsOfListChildren<T, SegmentOverride, Path, NextDepth>
+    : T extends ValidatingRecordTypeDef ? InternalFlattenedTypeDefsOfRecordChildren<T, SegmentOverride, Path, NextDepth>
+    : T extends ValidatingObjectTypeDef
+      ? InternalFlattenedTypeDefsOfObjectChildren<T, SegmentOverride, Path, Qualifier, NextDepth>
+    : T extends ValidatingUnionTypeDef
+      ? InternalFlattenedTypeDefsOfUnionChildren<T, SegmentOverride, Path, Qualifier, NextDepth>
+    : never
+
+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]
+        // if the field is optional, synthesize a nullable type
+        ? InternalFlattenedTypeDefsOf<
+          ValidatingUnionTypeDef<
+            ErrorOfValidatingTypeDef<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<{
+        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

package/types/flattened_validators_of_validating_type.ts

@@ -0,0 +1,33 @@
+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,
+  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
+    >
+}

package/types/flattened_values_of_type.ts

@@ -0,0 +1,11 @@
+import { type Type } from './definitions'
+import { type FlattenedTypesOfType } from './flattened_types_of_type'
+import { type ValueOfType } from './value_of_type'
+
+export type FlattenedValuesOfType<
+  T extends Type,
+  SegmentOverride extends string | null = null,
+  Flattened extends Readonly<Record<string, Type>> = FlattenedTypesOfType<T, SegmentOverride>,
+> = {
+  [K in keyof Flattened]: ValueOfType<Flattened[K], {}>
+}

package/types/{mobx_value_type_of.ts → mobx_value_of_type.ts}

@@ -1,7 +1,7 @@
 import {
   type Type,
 } from './definitions'
-import { type ValueTypeOf } from './value_type_of'
+import { type ValueOfType } from './value_of_type'
 
 const MOBX_OBSERVABLE_KEY = '___mobx_observable'
 
@@ -13,4 +13,4 @@ export type NonMobxObservable<T = {}> = {
   [MOBX_OBSERVABLE_KEY]?: never,
 } & T
 
-export type MobxValueTypeOf<T extends Type> = ValueTypeOf<T, MobxObservable>
+export type MobxValueOfType<T extends Type> = ValueOfType<T, MobxObservable>

package/types/{partial_type_def_of.ts → partial_type_of_type.ts}

@@ -9,8 +9,10 @@ import {
   type UnionTypeDef,
 } from './definitions'
 
+// TODO rename to PartialOfType
+
 // converts a type def to have nullable values and partial record fields
-export type PartialTypeDefOf<T extends Type> = {
+export type PartialTypeOfType<T extends Type> = {
   readonly typeDef: InternalPartialAndNullableOf<T['definition']>,
 }
 

package/types/{json_path_of.ts → path_of.ts}

@@ -1,4 +1,4 @@
-export type JsonPathOf<
+export type PathOf<
   Prefix extends string,
   Accessor extends string | number | symbol,
   SegmentOverride extends string | null = null,

package/types/{json_paths_of.ts → paths_of_type.ts}

@@ -11,9 +11,9 @@ import {
   type Depths,
   type StartingDepth,
 } from './flattened'
-import { type JsonPathOf } from './json_path_of'
+import { type PathOf } from './path_of'
 
-export type JsonPathsOf<
+export type PathsOfType<
   T extends Type,
   SegmentOverride extends string | null = null,
   Prefix extends string = '$',
@@ -57,7 +57,7 @@ type InternalJsonPathsOfListChildren<
   Depth extends number,
 > = InternalJsonPathsOf<
   F['elements'],
-  JsonPathOf<
+  PathOf<
     Prefix,
     number,
     SegmentOverride
@@ -73,7 +73,7 @@ type InternalJsonPathsOfRecordChildren<
   Depth extends number,
 > = InternalJsonPathsOf<
   F['valueTypeDef'],
-  JsonPathOf<
+  PathOf<
     Prefix,
     F['keyPrototype'],
     SegmentOverride
@@ -91,7 +91,7 @@ type InternalJsonPathsOfObjectChildren<
 > = F extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? {
       [K in keyof Fields]: InternalJsonPathsOf<
         Fields[K],
-        JsonPathOf<
+        PathOf<
           Prefix,
           `${Qualifier}${K}`,
           null

package/types/readonly_type_of_type.ts

@@ -0,0 +1,54 @@
+import {
+  type ListTypeDef,
+  type LiteralTypeDef,
+  type ObjectTypeDef,
+  type RecordTypeDef,
+  type Type,
+  type TypeDef,
+  type UnionTypeDef,
+} from './definitions'
+
+// TODO rename to ReadonlyOfType
+export type ReadonlyTypeOfType<T extends Type> = {
+  readonly definition: ReadonlyOfTypeDef<T['definition']>,
+}
+
+export type ReadonlyOfTypeDef<T extends TypeDef> = T extends LiteralTypeDef ? ReadonlyOfLiteralTypeDef<T>
+  : T extends ListTypeDef ? ReadonlyOfListTypeDef<T>
+  : T extends RecordTypeDef ? ReadonlyOfRecordTypeDef<T>
+  : T extends ObjectTypeDef ? ReadonlyOfObjectTypeDef<T>
+  : T extends UnionTypeDef ? ReadonlyOfUnionTypeDef<T>
+  : never
+
+type ReadonlyOfLiteralTypeDef<T extends LiteralTypeDef> = T
+
+type ReadonlyOfListTypeDef<T extends ListTypeDef> = {
+  readonly type: T['type'],
+  readonly elements: ReadonlyOfTypeDef<T['elements']>,
+}
+
+type ReadonlyOfRecordTypeDef<T extends RecordTypeDef> = {
+  readonly type: T['type'],
+  readonly keyPrototype: T['keyPrototype'],
+  readonly valueTypeDef: undefined extends T['valueTypeDef'] ? ReadonlyOfTypeDef<
+      Exclude<T['valueTypeDef'], undefined>
+    > | undefined
+    : ReadonlyOfTypeDef<T['valueTypeDef']>,
+}
+
+type ReadonlyOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: T['type'],
+    readonly fields: {
+      readonly [K in keyof Fields]: ReadonlyOfTypeDef<Fields[K]>
+    },
+  }
+  : never
+
+type ReadonlyOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
+    readonly type: T['type'],
+    readonly discriminator: D,
+    readonly unions: {
+      readonly [K in keyof Unions]: ReadonlyOfTypeDef<Unions[K]>
+    },
+  }
+  : never