@strictly/define 0.0.30 → 0.0.32

package/transformers/flatteners/{flatten_values_of_type.ts → flattenValuesOfType.ts}

@@ -1,10 +1,10 @@
-import { type Type } from 'types/definitions'
-import { type StrictTypeDef } from 'types/strict_definitions'
-import { type ValueOfType } from 'types/value_of_type'
+import { type StrictTypeDef } from 'types/StrictType'
+import { type Type } from 'types/Type'
+import { type ValueOfType } from 'types/ValueOfType'
 import {
   type AnyValueType,
   flattenValueTo,
-} from './flatten_value_to'
+} from './flattenValueTo'
 
 function mapper(_t: StrictTypeDef, v: AnyValueType) {
   return v

package/transformers/flatteners/specs/{flatten_accessors_of_type.tests.ts → flattenAccessorsOfType.tests.ts}

@@ -1,13 +1,13 @@
 import { expectDefinedAndReturn } from '@strictly/base'
-import { flattenAccessorsOfType } from 'transformers/flatteners/flatten_accessors_of_type'
+import { flattenAccessorsOfType } from 'transformers/flatteners/flattenAccessorsOfType'
 import {
   booleanType,
   list,
   numberType,
   object,
 } from 'types/builders'
-import { type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type'
-import { type ValueOfType } from 'types/value_of_type'
+import { type FlattenedAccessorsOfType } from 'types/FlattenedAccessorsOfType'
+import { type ValueOfType } from 'types/ValueOfType'
 import {
   type Mock,
   vi,

package/transformers/flatteners/specs/{flatten_json_value_to_type_paths_of.tests.ts → flattenJsonValueToTypePathsOf.tests.ts}

@@ -1,4 +1,4 @@
-import { flattenJsonValueToTypePathsOf } from 'transformers/flatteners/flatten_json_value_to_type_paths_of'
+import { flattenJsonValueToTypePathsOf } from 'transformers/flatteners/flattenJsonValueToTypePathsOf'
 import {
   booleanType,
   list,
@@ -108,6 +108,7 @@ describe('flattenJsonValueToTypePathsOf', function () {
           $: '$',
           '$:x.a': '$:x.a',
           '$:x.b': '$:x.b',
+          '$:x.d': '$:x.d',
         })
       })
     })

package/transformers/flatteners/specs/{flatten_type_to.tests.ts → flattenTypeTo.tests.ts}

@@ -1,4 +1,4 @@
-import { flattenTypeTo } from 'transformers/flatteners/flatten_type_to'
+import { flattenTypeTo } from 'transformers/flatteners/flattenTypeTo'
 import {
   booleanType,
   list,
@@ -11,7 +11,7 @@ import {
 import {
   type TypeDef,
   TypeDefType,
-} from 'types/definitions'
+} from 'types/Type'
 import {
   type Mock,
   vi,
@@ -136,12 +136,14 @@ describe('flattenTypeDefTo', function () {
         expect(flattened).toEqual({
           $: TypeDefType.Union,
           '$:a.a': TypeDefType.Literal,
+          '$:a.d': TypeDefType.Literal,
           '$:b.b': TypeDefType.Literal,
+          '$:b.d': TypeDefType.Literal,
         })
       })
 
       it('calls the mapper function', function () {
-        expect(toTypeDefType).toHaveBeenCalledTimes(3)
+        expect(toTypeDefType).toHaveBeenCalledTimes(5)
       })
     })
   })

package/transformers/flatteners/specs/{flatten_types_of_type.tests.ts → flattenTypesOfType.tests.ts}

@@ -1,4 +1,4 @@
-import { flattenTypesOfType } from 'transformers/flatteners/flatten_types_of_type'
+import { flattenTypesOfType } from 'transformers/flatteners/flattenTypesOfType'
 import {
   booleanType,
   list,

package/transformers/flatteners/specs/{flatten_validation_errors_of_type.tests.ts → flattenValidationErrorsOfType.tests.ts}

@@ -1,6 +1,6 @@
-import { flattenValidationErrorsOfType } from 'transformers/flatteners/flatten_validation_errors_of_type'
+import { flattenValidationErrorsOfType } from 'transformers/flatteners/flattenValidationErrorsOfType'
 import { literal } from 'types/builders'
-import { type ValueToTypePathsOfType } from 'types/value_to_type_paths_of_type'
+import { type ValueToTypePathsOfType } from 'types/ValueToTypePathsOfType'
 
 describe('flattenValidationsOfType', function () {
   describe('literal', function () {

package/transformers/flatteners/specs/{flatten_value_to.tests.ts → flattenValueTo.tests.ts}

@@ -3,7 +3,7 @@ import {
   flattenValueTo,
   type Mapper,
   type Setter,
-} from 'transformers/flatteners/flatten_value_to'
+} from 'transformers/flatteners/flattenValueTo'
 import { type SimplifyDeep } from 'type-fest'
 import {
   booleanType,
@@ -15,12 +15,12 @@ import {
   record,
   union,
 } from 'types/builders'
+import { type FlattenedTypesOfType } from 'types/FlattenedTypesOfType'
 import {
   type Type,
   type TypeDef,
-} from 'types/definitions'
-import { type FlattenedTypesOfType } from 'types/flattened_types_of_type'
-import { type ValueOfType } from 'types/value_of_type'
+} from 'types/Type'
+import { type ValueOfType } from 'types/ValueOfType'
 import {
   type Mock,
   vi,
@@ -330,6 +330,7 @@ describe('flattenValueTo', function () {
           expect(flattened).toEqual({
             $: '{"d":"1","a":2}',
             ['$:1.a']: '2',
+            ['$:1.d']: '"1"',
           })
         })
       })

package/transformers/flatteners/specs/{flatten_values_of_type.tests.ts → flattenValuesOfType.tests.ts}

@@ -1,4 +1,4 @@
-import { flattenValuesOfType } from 'transformers/flatteners/flatten_values_of_type'
+import { flattenValuesOfType } from 'transformers/flatteners/flattenValuesOfType'
 import {
   booleanType,
   list,

package/transformers/flatteners/specs/{json_paths.tests.ts → jsonPaths.tests.ts}

@@ -2,7 +2,7 @@ import {
   jsonPath,
   jsonPathPrefix,
   jsonPathUnprefix,
-} from 'transformers/flatteners/json_path'
+} from 'transformers/flatteners/jsonPath'
 
 describe('json_paths', () => {
   describe('jsonPath', () => {

package/transformers/flatteners/specs/{value_path_to_type_path.tests.ts → valuePathToTypePath.tests.ts}

@@ -1,4 +1,4 @@
-import { valuePathToTypePath } from 'transformers/flatteners/value_path_to_type_path'
+import { valuePathToTypePath } from 'transformers/flatteners/valuePathToTypePath'
 import {
   booleanType,
   list,
@@ -8,7 +8,7 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type ValueToTypePathsOfType } from 'types/value_to_type_paths_of_type'
+import { type ValueToTypePathsOfType } from 'types/ValueToTypePathsOfType'
 
 describe('valuePathToTypePath', function () {
   describe('literal', function () {

package/transformers/flatteners/{value_path_to_type_path.ts → valuePathToTypePath.ts}

@@ -10,7 +10,7 @@ import {
   type Type,
   type TypeDef,
   TypeDefType,
-} from 'types/definitions'
+} from 'types/Type'
 
 export function valuePathToTypePath<
   ValuePathsToTypePaths extends Record<string, string>,

package/types/{flattened_accessors_of_type.ts → FlattenedAccessorsOfType.ts}

@@ -1,5 +1,5 @@
-import { type Type } from './definitions'
-import { type FlattenedValuesOfType } from './flattened_values_of_type'
+import { type FlattenedValuesOfType } from './FlattenedValuesOfType'
+import { type Type } from './Type'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Accessor<T = any> = {

package/types/{flattened_types_of_type.ts → FlattenedTypesOfType.ts}

@@ -1,6 +1,11 @@
 import {
   type UnionToIntersection,
 } from 'type-fest'
+import {
+  type Depths,
+  type StartingDepth,
+} from './flattened'
+import { type PathOf } from './PathOf'
 import {
   type ListTypeDef,
   type LiteralTypeDef,
@@ -9,12 +14,7 @@ import {
   type Type,
   type TypeDef,
   type UnionTypeDef,
-} from './definitions'
-import {
-  type Depths,
-  type StartingDepth,
-} from './flattened'
-import { type PathOf } from './path_of'
+} from './Type'
 
 // NOTE removing any ternary from this file improves the performance and the depth of data structure we can go to
 

package/types/{flattened_types_of_validating_type.ts → FlattenedTypesOfValidatingType.ts}

@@ -1,15 +1,15 @@
 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 PathOf } from './PathOf'
+import {
+  type Type,
+  type TypeDef,
+} from './Type'
 import {
   type ContextOfValidatingTypeDef,
   type ErrorOfValidatingTypeDef,
@@ -18,7 +18,7 @@ import {
   type ValidatingObjectTypeDef,
   type ValidatingRecordTypeDef,
   type ValidatingUnionTypeDef,
-} from './validating_definitions'
+} from './ValidatingType'
 
 // TODO rename to FlattenedValidatingTypesOfValidatingType
 export type FlattenedTypesOfValidatingType<

package/types/{flattened_validators_of_validating_type.ts → FlattenedValidatorsOfValidatingType.ts}

@@ -1,17 +1,17 @@
 import { type Simplify } from 'type-fest'
 import { type Validator } from 'validation/validator'
-import { type FlattenedTypesOfType } from './flattened_types_of_type'
+import { type FlattenedTypesOfType } from './FlattenedTypesOfType'
 import {
   type ReadonlyOfTypeDef,
-} from './readonly_type_of_type'
+} from './ReadonlyTypeOfType'
 import {
   type ErrorOfValidatingTypeDef,
   type ValidatingType,
   type ValidatingTypeDef,
-} from './validating_definitions'
+} from './ValidatingType'
 import {
   type ValueOfTypeDef,
-} from './value_of_type'
+} from './ValueOfType'
 
 type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string> = T extends
   ValidatingTypeDef<infer E, infer C> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, C>

package/types/{flattened_values_of_type.ts → FlattenedValuesOfType.ts}

@@ -1,6 +1,6 @@
-import { type Type } from './definitions'
-import { type FlattenedTypesOfType } from './flattened_types_of_type'
-import { type ValueOfType } from './value_of_type'
+import { type FlattenedTypesOfType } from './FlattenedTypesOfType'
+import { type Type } from './Type'
+import { type ValueOfType } from './ValueOfType'
 
 export type FlattenedValuesOfType<
   T extends Type,

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

@@ -1,7 +1,7 @@
 import {
   type Type,
-} from './definitions'
-import { type ValueOfType } from './value_of_type'
+} from './Type'
+import { type ValueOfType } from './ValueOfType'
 
 const MOBX_OBSERVABLE_KEY = '___mobx_observable'
 

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

@@ -7,7 +7,7 @@ import {
   type TypeDef,
   type TypeDefType,
   type UnionTypeDef,
-} from './definitions'
+} from './Type'
 
 // TODO rename to PartialOfType
 

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

@@ -1,3 +1,8 @@
+import {
+  type Depths,
+  type StartingDepth,
+} from './flattened'
+import { type PathOf } from './PathOf'
 import {
   type ListTypeDef,
   type LiteralTypeDef,
@@ -6,12 +11,7 @@ import {
   type Type,
   type TypeDef,
   type UnionTypeDef,
-} from './definitions'
-import {
-  type Depths,
-  type StartingDepth,
-} from './flattened'
-import { type PathOf } from './path_of'
+} from './Type'
 
 export type PathsOfType<
   T extends Type,

package/types/{readonly_type_of_type.ts → ReadonlyTypeOfType.ts}

@@ -6,7 +6,7 @@ import {
   type Type,
   type TypeDef,
   type UnionTypeDef,
-} from './definitions'
+} from './Type'
 
 // TODO rename to ReadonlyOfType
 export type ReadonlyTypeOfType<T extends Type> = {

package/types/{strict_definitions.ts → StrictType.ts}

@@ -7,7 +7,7 @@ import {
   type RecordKeyType,
   type TypeDefType,
   type UnionKey,
-} from './definitions'
+} from './Type'
 
 // TODO rename to something more descriptive (e.g. introspectable definitions, deterministic
 // definitions, discriminated definitions). Maybe should just replace definitions since most

package/types/{validating_definitions.ts → ValidatingType.ts}

@@ -4,7 +4,7 @@ import {
   type RecordKeyType,
   type TypeDefType,
   type UnionKey,
-} from './definitions'
+} from './Type'
 
 // type defs with error types, lets us attach validation to types
 

package/types/{validating_type_def_with_error.ts → ValidatingTypeDefWithError.ts}

@@ -1,7 +1,7 @@
 import { type IsFieldReadonly } from '@strictly/base'
 import {
   type TypeDefType,
-} from 'types/definitions'
+} from './Type'
 import {
   type Rule,
   type ValidatingListTypeDef,
@@ -10,7 +10,7 @@ import {
   type ValidatingRecordTypeDef,
   type ValidatingTypeDef,
   type ValidatingUnionTypeDef,
-} from './validating_definitions'
+} from './ValidatingType'
 
 // doesn't work, loses
 // export type ValidatingTypeDefWithError2<T extends ValidatingTypeDef, E2> = T extends ValidatingTypeDef<infer E1>

package/types/{value_of_type.ts → ValueOfType.ts}

@@ -9,7 +9,7 @@ import {
   type Type,
   type TypeDef,
   type UnionTypeDef,
-} from './definitions'
+} from './Type'
 
 export type ValueOfType<
   T,

package/types/{value_to_type_paths_of_type.ts → ValueToTypePathsOfType.ts}

@@ -2,6 +2,12 @@ import {
   type SimplifyDeep,
   type UnionToIntersection,
 } from 'type-fest'
+import {
+  type Depths,
+  type StartingDepth,
+} from './flattened'
+import { type PathOf } from './PathOf'
+import { type StrictType } from './StrictType'
 import {
   type ListTypeDef,
   type LiteralTypeDef,
@@ -9,13 +15,7 @@ import {
   type RecordTypeDef,
   type TypeDef,
   type UnionTypeDef,
-} from './definitions'
-import {
-  type Depths,
-  type StartingDepth,
-} from './flattened'
-import { type PathOf } from './path_of'
-import { type StrictType } from './strict_definitions'
+} from './Type'
 
 export type ValueToTypePathsOfType<
   T extends StrictType,

package/types/{value_types_of_discriminated_union.ts → ValueTypesOfDiscriminatedUnion.ts}

@@ -1,6 +1,6 @@
-import { type UnionTypeDef } from './definitions'
-import { type ReadonlyTypeOfType } from './readonly_type_of_type'
-import { type ValueOfType } from './value_of_type'
+import { type ReadonlyTypeOfType } from './ReadonlyTypeOfType'
+import { type UnionTypeDef } from './Type'
+import { type ValueOfType } from './ValueOfType'
 
 // gets a record of the values types for a discriminated union mapped according to
 // their discriminators

package/types/builders.ts

@@ -1,5 +1,7 @@
 import {
   type IsFieldReadonly,
+  map,
+  UnreachableError,
 } from '@strictly/base'
 import {
   isAnnotatedValidator,
@@ -14,11 +16,11 @@ import {
   type TypeDef,
   TypeDefType,
   type UnionKey,
-} from './definitions'
+} from './Type'
 import {
   type TypeOfType,
   typeOfType,
-} from './type_of_type'
+} from './typeOfType'
 import {
   type Rule,
   type ValidatingListTypeDef,
@@ -28,12 +30,12 @@ import {
   type ValidatingType,
   type ValidatingTypeDef,
   type ValidatingUnionTypeDef,
-} from './validating_definitions'
-import { type ValidatingTypeDefWithError } from './validating_type_def_with_error'
+} from './ValidatingType'
+import { type ValidatingTypeDefWithError } from './ValidatingTypeDefWithError'
 import {
   type ValueOfType,
   type ValueOfTypeDef,
-} from './value_of_type'
+} from './ValueOfType'
 
 function emptyRule() {
   return null
@@ -343,20 +345,56 @@ class UnionTypeDefBuilder<
   ): UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U> {
     const {
       unions,
+      discriminator,
     } = this.definition
+    // add the discriminator as a field to the underlying union type
+    const enhancedTypeDef = maybeAddDiscriminatorField(typeDef, discriminator, k)
     return new UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U>(
       {
         ...this.definition,
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         unions: {
           ...unions,
-          [k]: typeDef,
+          [k]: enhancedTypeDef,
         } as Readonly<Record<K, T>> & U,
       },
     )
   }
 }
 
+function maybeAddDiscriminatorField<T extends TypeDef, K extends UnionKey>(
+  t: T,
+  discriminatorKey: string | null,
+  discriminatorLiteral: K,
+): T {
+  if (discriminatorKey == null) {
+    return t
+  }
+  switch (t.type) {
+    case TypeDefType.List:
+    case TypeDefType.Literal:
+    case TypeDefType.Record:
+      return t
+    case TypeDefType.Object:
+      return {
+        ...t,
+        fields: {
+          ...t.fields,
+          [discriminatorKey]: literal([discriminatorLiteral]).readonly().required().narrow.definition,
+        },
+      }
+    case TypeDefType.Union:
+      return {
+        ...t,
+        unions: map(t.unions, (_k, v) => {
+          return maybeAddDiscriminatorField(v, discriminatorKey, discriminatorLiteral)
+        }),
+      }
+    default:
+      throw new UnreachableError(t)
+  }
+}
+
 export function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, T>> {
   return new TypeDefBuilder({
     type: TypeDefType.Literal,

package/types/flattened.ts

@@ -1,5 +1,5 @@
 // Unfortunately the TS compiler will infinitely loop if we don't give it a way of breaking out.
 // A starting depth of 10 (the maximum) will cause performance issues while developing
-export type StartingDepth = 8
+export type StartingDepth = 5
 // Going much above a depth of 10 will also blow up
 export type Depths = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]

package/types/specs/{flattened_accessors_of_type.tests.ts → FlattenedAccessorsOfType.tests.ts}

@@ -2,7 +2,7 @@ import {
   numberType,
   record,
 } from 'types/builders'
-import { type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type'
+import { type FlattenedAccessorsOfType } from 'types/FlattenedAccessorsOfType'
 
 describe('FlattenedAccessorsOfType', function () {
   // note we only test a small example since most of the work is done in flatten

package/types/specs/{flattened_types_of_type.tests.ts → FlattenedTypesOfType.tests.ts}

@@ -8,8 +8,8 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type TypeDefType } from 'types/definitions'
-import { type FlattenedTypesOfType } from 'types/flattened_types_of_type'
+import { type FlattenedTypesOfType } from 'types/FlattenedTypesOfType'
+import { type TypeDefType } from 'types/Type'
 
 describe('FlattenedTypesOfType', function () {
   describe('literal', function () {

package/types/specs/{flattened_validators_of_validating_type.tests.ts → FlattenedValidatorsOfValidatingType.tests.ts}

@@ -3,8 +3,8 @@ import {
   list,
   numberType,
 } from 'types/builders'
-import { type FlattenedValidatorsOfValidatingType } from 'types/flattened_validators_of_validating_type'
-import { type ValueToTypePathsOfType } from 'types/value_to_type_paths_of_type'
+import { type FlattenedValidatorsOfValidatingType } from 'types/FlattenedValidatorsOfValidatingType'
+import { type ValueToTypePathsOfType } from 'types/ValueToTypePathsOfType'
 import { type Validator } from 'validation/validator'
 
 describe('FlattenedValidatorsOfValidatingType', function () {

package/types/specs/{flattened_values_of_type.tests.ts → FlattenedValuesOfType.tests.ts}

@@ -4,7 +4,7 @@ import {
   record,
   stringType,
 } from 'types/builders'
-import { type FlattenedValuesOfType } from 'types/flattened_values_of_type'
+import { type FlattenedValuesOfType } from 'types/FlattenedValuesOfType'
 
 describe('FlattenedValuesOfType', function () {
   // note we only test a small example since most of the work is done in flatten

package/types/specs/{partial_type_of_type.tests.ts → PartialTypeOfType.tests.ts}

@@ -7,8 +7,8 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type TypeDefType } from 'types/definitions'
-import { type PartialTypeOfType } from 'types/partial_type_of_type'
+import { type PartialTypeOfType } from 'types/PartialTypeOfType'
+import { type TypeDefType } from 'types/Type'
 
 describe('PartialTypeDefOf', function () {
   describe('literal', function () {

package/types/specs/{paths_of_type.tests.ts → PathsOfType.tests.ts}

@@ -8,7 +8,7 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type PathsOfType } from 'types/paths_of_type'
+import { type PathsOfType } from 'types/PathsOfType'
 
 describe('PathsOfType', function () {
   describe('literal', function () {

package/types/specs/{readonly_type_of_type.tests.ts → ReadonlyTypeOfType.tests.ts}

@@ -6,8 +6,8 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type TypeDefType } from 'types/definitions'
-import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type'
+import { type ReadonlyTypeOfType } from 'types/ReadonlyTypeOfType'
+import { type TypeDefType } from 'types/Type'
 
 describe('ReadonlyTypeDefOf', function () {
   describe('literal', function () {

package/types/specs/{strict_definitions.tests.ts → StrictType.tests.ts}

@@ -1,11 +1,11 @@
-import {
-  type TypeDefType,
-  type UnionTypeDef,
-} from 'types/definitions'
 import {
   type IsStrictUnion,
   type StrictUnionTypeDef,
-} from 'types/strict_definitions'
+} from 'types/StrictType'
+import {
+  type TypeDefType,
+  type UnionTypeDef,
+} from 'types/Type'
 
 describe('Strict Definitions', function () {
   describe('IsStrictUnion', function () {

package/types/specs/{type_of_type.tests.ts → TypeOfType.tests.ts}

@@ -2,8 +2,8 @@ import {
   list,
   numberType,
 } from 'types/builders'
-import { type TypeDefType } from 'types/definitions'
-import { type TypeOfType } from 'types/type_of_type'
+import { type TypeDefType } from 'types/Type'
+import { type TypeOfType } from 'types/typeOfType'
 
 describe('TypeOfType', function () {
   describe('literal', function () {

package/types/specs/{value_of_type.tests.ts → ValueOfType.tests.ts}

@@ -1,8 +1,8 @@
 import { type SimplifyDeep } from 'type-fest'
 import {
   type TypeDefType,
-} from 'types/definitions'
-import { type ValueOfType } from 'types/value_of_type'
+} from 'types/Type'
+import { type ValueOfType } from 'types/ValueOfType'
 
 describe('ValueOfType', function () {
   describe('literal', function () {