@strictly/define 0.0.1 → 0.0.3

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

@@ -14,14 +14,14 @@ import {
   type Depths,
   type StartingDepth,
 } from './flattened'
-import { type JsonPathOf } from './json_path_of'
+import { type PathOf } from './path_of'
 import { type StrictType } from './strict_definitions'
 
-export type ValueToTypePathsOf<
+export type ValueToTypePathsOfType<
   T extends StrictType,
   SegmentOverride extends string = '*',
   Path extends string = '$',
-> = SimplifyDeep<InternalFlattenedJsonPathsOf<
+> = SimplifyDeep<InternalFlattenedTypePathsOf<
   T['definition'],
   SegmentOverride,
   Path,
@@ -29,7 +29,8 @@ export type ValueToTypePathsOf<
   StartingDepth
 >>
 
-type InternalFlattenedJsonPathsOf<
+// TODO rename to FlattenTypePathsOfTypeDef and apply pattern to subsequent types
+type InternalFlattenedTypePathsOf<
   T extends TypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
@@ -39,9 +40,9 @@ type InternalFlattenedJsonPathsOf<
   & {
     readonly [K in ValuePath]: TypePath
   }
-  & InternalFlattenedJsonPathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>
+  & InternalFlattenedTypePathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>
 
-type InternalFlattenedJsonPathsOfChildren<
+type InternalFlattenedTypePathsOfChildren<
   T extends TypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
@@ -50,22 +51,22 @@ type InternalFlattenedJsonPathsOfChildren<
   Depth extends number,
   NextDepth extends number = Depths[Depth],
 > = NextDepth extends -1 ? never
-  : T extends LiteralTypeDef ? InternalFlattenedJsonPathsOfLiteralChildren
-  : T extends ListTypeDef ? InternalFlattenedJsonPathsOfListChildren<
+  : T extends LiteralTypeDef ? InternalFlattenedTypePathsOfLiteralChildren
+  : T extends ListTypeDef ? InternalFlattenedTypePathsOfListChildren<
       T,
       SegmentOverride,
       ValuePath,
       TypePath,
       NextDepth
     >
-  : T extends RecordTypeDef ? InternalFlattenedJsonPathsOfRecordChildren<
+  : T extends RecordTypeDef ? InternalFlattenedTypePathsOfRecordChildren<
       T,
       SegmentOverride,
       ValuePath,
       TypePath,
       NextDepth
     >
-  : T extends ObjectTypeDef ? InternalFlattenedJsonPathsOfObjectChildren<
+  : T extends ObjectTypeDef ? InternalFlattenedTypePathsOfObjectChildren<
       T,
       SegmentOverride,
       ValuePath,
@@ -73,7 +74,7 @@ type InternalFlattenedJsonPathsOfChildren<
       Qualifier,
       NextDepth
     >
-  : T extends UnionTypeDef ? InternalFlattenedJsonPathsOfUnionChildren<
+  : T extends UnionTypeDef ? InternalFlattenedTypePathsOfUnionChildren<
       T,
       SegmentOverride,
       ValuePath,
@@ -83,37 +84,37 @@ type InternalFlattenedJsonPathsOfChildren<
     >
   : never
 
-type InternalFlattenedJsonPathsOfLiteralChildren = {}
+type InternalFlattenedTypePathsOfLiteralChildren = {}
 
-type InternalFlattenedJsonPathsOfListChildren<
+type InternalFlattenedTypePathsOfListChildren<
   T extends ListTypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
   TypePath extends string,
   Depth extends number,
-> = InternalFlattenedJsonPathsOf<
+> = InternalFlattenedTypePathsOf<
   T['elements'],
   SegmentOverride,
-  JsonPathOf<ValuePath, number>,
-  JsonPathOf<TypePath, number, SegmentOverride>,
+  PathOf<ValuePath, number>,
+  PathOf<TypePath, number, SegmentOverride>,
   Depth
 >
 
-type InternalFlattenedJsonPathsOfRecordChildren<
+type InternalFlattenedTypePathsOfRecordChildren<
   T extends RecordTypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
   TypePath extends string,
   Depth extends number,
-> = InternalFlattenedJsonPathsOf<
+> = InternalFlattenedTypePathsOf<
   T['valueTypeDef'],
   SegmentOverride,
-  JsonPathOf<ValuePath, T['keyPrototype']>,
-  JsonPathOf<TypePath, T['keyPrototype'], SegmentOverride>,
+  PathOf<ValuePath, T['keyPrototype']>,
+  PathOf<TypePath, T['keyPrototype'], SegmentOverride>,
   Depth
 >
 
-type InternalFlattenedJsonPathsOfObjectChildren<
+type InternalFlattenedTypePathsOfObjectChildren<
   T extends ObjectTypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
@@ -122,11 +123,11 @@ type InternalFlattenedJsonPathsOfObjectChildren<
   Depth extends number,
 > = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<
       {
-        readonly [K in keyof Fields]-?: InternalFlattenedJsonPathsOf<
+        readonly [K in keyof Fields]-?: InternalFlattenedTypePathsOf<
           Exclude<Fields[K], undefined>,
           SegmentOverride,
-          JsonPathOf<ValuePath, `${Qualifier}${K}`>,
-          JsonPathOf<TypePath, `${Qualifier}${K}`>,
+          PathOf<ValuePath, `${Qualifier}${K}`>,
+          PathOf<TypePath, `${Qualifier}${K}`>,
           Depth
         >
       }[keyof Fields]
@@ -134,7 +135,7 @@ type InternalFlattenedJsonPathsOfObjectChildren<
   : never
   : never
 
-// type InternalFlattenedJsonPathsOfUnionChildren<
+// type InternalFlattenedTypePathsOfUnionChildren<
 //   T extends UnionTypeDef,
 //   SegmentOverride extends string,
 //   ValuePath extends string,
@@ -142,7 +143,7 @@ type InternalFlattenedJsonPathsOfObjectChildren<
 //   Depth extends number,
 // > = T extends UnionTypeDef<infer D, infer Unions> ?
 //     & ({
-//       [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<
+//       [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<
 //         Unions[K],
 //         SegmentOverride,
 //         ValuePath,
@@ -153,7 +154,7 @@ type InternalFlattenedJsonPathsOfObjectChildren<
 //     & (D extends string ? ReadonlyRecord<JsonPathOf<ValuePath, D>, JsonPathOf<TypePath, D>> : {})
 //   : never
 
-type InternalFlattenedJsonPathsOfUnionChildren<
+type InternalFlattenedTypePathsOfUnionChildren<
   T extends UnionTypeDef,
   SegmentOverride extends string,
   ValuePath extends string,
@@ -161,7 +162,7 @@ type InternalFlattenedJsonPathsOfUnionChildren<
   Qualifier extends string,
   Depth extends number,
 > = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
-        readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<
+        readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<
           Unions[K],
           SegmentOverride,
           ValuePath,
@@ -171,7 +172,7 @@ type InternalFlattenedJsonPathsOfUnionChildren<
         >
       }[keyof Unions]>
     : UnionToIntersection<{
-      readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<
+      readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<
         Unions[K],
         SegmentOverride,
         ValuePath,

package/types/value_types_of_discriminated_union.ts

@@ -1,13 +1,14 @@
 import { type UnionTypeDef } from './definitions'
-import { type ValueTypeOf } from './value_type_of'
+import { type ReadonlyTypeOfType } from './readonly_type_of_type'
+import { type ValueOfType } from './value_of_type'
 
 // gets a record of the values types for a discriminated union mapped according to
 // their discriminators
 export type ValueTypesOfDiscriminatedUnion<
   U extends UnionTypeDef,
 > = U extends UnionTypeDef<infer D, infer Unions> ? D extends string ? {
-      [K in keyof Unions]: ValueTypeOf<{ definition: Unions[K] }> & {
-        [KD in D]: K
+      [K in keyof Unions]: ValueOfType<ReadonlyTypeOfType<{ definition: Unions[K] }>> & {
+        readonly [KD in D]: K
       }
     }
   : never

package/validation/errors_of_validators.ts

@@ -0,0 +1,10 @@
+import {
+  type ErrorOfValidator,
+  type Validator,
+} from 'validation/validator'
+
+export type ErrorsOfValidators<
+  Validators extends Record<string, Validator>,
+> = {
+  readonly [K in keyof Validators]: ErrorOfValidator<Validators[K]>
+}

package/validation/specs/errors_of_validators.tests.ts

@@ -0,0 +1,20 @@
+import { type ErrorsOfValidators } from 'validation/errors_of_validators'
+import { type Validator } from 'validation/validator'
+
+describe('ErrorsOfValidators', function () {
+  describe('simple', function () {
+    type T = ErrorsOfValidators<{
+      x: Validator<string, 'a'>,
+      y: Validator<number, 'b'>,
+    }>
+
+    let t: {
+      readonly x: 'a',
+      readonly y: 'b',
+    }
+
+    it('equals expected type', function () {
+      expectTypeOf<T>().toEqualTypeOf(t)
+    })
+  })
+})

package/validation/specs/validators_of_values.tests.ts

@@ -0,0 +1,68 @@
+import { type Validator } from 'validation/validator'
+import { type ValidatorsOfValues } from 'validation/validators_of_values'
+
+describe('FlattenedValidatorsOfType', function () {
+  describe('literal', function () {
+    type T = ValidatorsOfValues<
+      {
+        $: 'a' | 'b' | 'c',
+      },
+      {
+        $: '$',
+      },
+      1
+    >
+
+    let t: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      readonly $: Validator<'a' | 'b' | 'c', any, '$', 1>,
+    }
+
+    it('has the expected type', function () {
+      expectTypeOf<T>().toEqualTypeOf(t)
+    })
+  })
+
+  describe('list', function () {
+    type T = ValidatorsOfValues<
+      {
+        $: number[],
+        '$.*': number,
+      },
+      {
+        $: '$',
+        '$.*': `$.${number}`,
+      },
+      2
+    >
+
+    let t: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      readonly $: Validator<number[], any, '$', 2>,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      readonly '$.*': Validator<number, any, `$.${number}`, 2>,
+    }
+
+    it('has the expected type', function () {
+      expectTypeOf<T>().toEqualTypeOf(t)
+    })
+  })
+
+  describe('with defaults', function () {
+    type T = ValidatorsOfValues<
+      {
+        $: number[],
+        '$.*': number,
+      }
+    >
+
+    let t: {
+      readonly $: Validator<number[]>,
+      readonly '$.*': Validator<number>,
+    }
+
+    it('has the expected type', function () {
+      expectTypeOf<T>().toEqualTypeOf(t)
+    })
+  })
+})

package/validation/validator.ts

@@ -0,0 +1,103 @@
+import { type Simplify } from 'type-fest'
+
+export type FunctionalValidator<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+> = (v: V, valuePath: ValuePath, context: Context) => E | null
+
+export type AnnotatedValidator<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+> = {
+  readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null,
+  readonly annotations: (valuePath: ValuePath, context: Context) => {
+    readonly required: boolean,
+    readonly readonly: boolean,
+  },
+}
+
+export type Validator<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>
+
+export type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never
+
+export type ValidationError<Type extends string, Data = {}> = Simplify<
+  {
+    type: Type,
+  } & Data
+>
+
+export function isFunctionalValidator(v: Validator): v is FunctionalValidator {
+  return typeof v === 'function'
+}
+
+export function isAnnotatedValidator(v: Validator): v is AnnotatedValidator {
+  return typeof v !== 'function'
+}
+
+export function validate<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+>(
+  validator: Validator<V, E, ValuePath, Context>,
+  v: V,
+  valuePath: ValuePath,
+  context: Context,
+): E | null {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context)
+  } else {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return (validator as FunctionalValidator<V, E, ValuePath, Context>)(v, valuePath, context)
+  }
+}
+
+export function annotations<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  V = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ValuePath extends string = any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+>(
+  validator: Validator<V, E, ValuePath, Context>,
+  valuePath: ValuePath,
+  context: Context,
+) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context)
+  } else {
+    return {
+      required: false,
+      readonly: false,
+    }
+  }
+}

package/validation/validators/defined_validator.ts

@@ -0,0 +1,22 @@
+import { type AnnotatedValidator } from 'validation/validator'
+
+export class DefinedValidator<V, E, ValuePath extends string, Context>
+  implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context>
+{
+  constructor(private readonly error: E) {
+  }
+
+  validate(v: V | null | undefined): E | null {
+    if (v == null) {
+      return this.error
+    }
+    return null
+  }
+
+  annotations() {
+    return {
+      required: true,
+      readonly: false,
+    }
+  }
+}

package/validation/validators/minimum_string_length_validator.ts

@@ -0,0 +1,36 @@
+import {
+  type AnnotatedValidator,
+} from 'validation/validator'
+
+export const MinimumStringLengthValidationErrorType = 'minimum_string_length'
+
+export type MinimumStringLengthValidationError = {
+  type: typeof MinimumStringLengthValidationErrorType,
+  receivedLength: number,
+  minimumLength: number,
+}
+
+export class MinimumStringLengthValidator<ValuePath extends string, Context>
+  implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context>
+{
+  constructor(private readonly minimumLength: number) {
+  }
+
+  validate(value: string): MinimumStringLengthValidationError | null {
+    if (value.length < this.minimumLength) {
+      return {
+        type: MinimumStringLengthValidationErrorType,
+        minimumLength: this.minimumLength,
+        receivedLength: value.length,
+      }
+    }
+    return null
+  }
+
+  annotations() {
+    return {
+      required: true,
+      readonly: false,
+    }
+  }
+}

package/validation/validators_of_values.ts

@@ -0,0 +1,17 @@
+import { type Validator } from 'validation/validator'
+
+export type ValidatorsOfValues<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  FlattenedValues extends Readonly<Record<string, any>>,
+  TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Record<keyof FlattenedValues, any>
+  >,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Context = any,
+> = {
+  readonly [
+    K in keyof FlattenedValues
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>
+}

package/.out/transformers/flatteners/flatten_accessors_of.d.ts

@@ -1,5 +0,0 @@
-import { type Type } from 'types/definitions';
-import { type Accessor, type FlattenedAccessorsOf } from 'types/flattened_accessors_of';
-import { type ValueTypeOf } from 'types/value_type_of';
-import { type Setter } from './flatten_value_type_to';
-export declare function flattenAccessorsOf<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOf<T>>(t: T, value: ValueTypeOf<T>, setValue: Setter<ValueTypeOf<T>>): R;

package/.out/transformers/flatteners/flatten_accessors_of.js

@@ -1,11 +0,0 @@
-import { flattenValueTypeTo, } from './flatten_value_type_to';
-function mapAccessor(_t, value, set) {
-    return {
-        value,
-        set,
-    };
-}
-export function flattenAccessorsOf(t, value, setValue) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return flattenValueTypeTo(t, value, setValue, mapAccessor);
-}

package/.out/transformers/flatteners/flatten_type_defs_of.js

@@ -1,7 +0,0 @@
-import { flattenTypeDefTo } from './flatten_type_def_to';
-export function flattenTypeDefsOf(t) {
-    // Type should be FlattenedTypeDefsOf<T>, but infinite depth error
-    return flattenTypeDefTo(t, function (definition) {
-        return { definition };
-    });
-}

package/.out/transformers/flatteners/flatten_value_types_of.d.ts

@@ -1,3 +0,0 @@
-import { type Type } from 'types/definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
-export declare function flattenValueTypesOf<T extends Type>(typeDef: Type, value: ValueTypeOf<T>): Readonly<Record<string, any>>;

package/.out/transformers/flatteners/flatten_value_types_of.js

@@ -1,7 +0,0 @@
-import { flattenValueTypeTo, } from './flatten_value_type_to';
-function mapper(_t, v) {
-    return v;
-}
-export function flattenValueTypesOf(typeDef, value) {
-    return flattenValueTypeTo(typeDef, value, () => { }, mapper);
-}

package/.out/transformers/flatteners/specs/flatten_type_defs_of.tests.js

@@ -1,17 +0,0 @@
-import { flattenTypeDefsOf } from 'transformers/flatteners/flatten_type_defs_of';
-import { booleanType, list, numberType, object, } from 'types/builders';
-describe('flattenTypeDefsOf', function () {
-    it('flattens', function () {
-        const listTypeDef = list(numberType);
-        const structTypeDef = object()
-            .set('a', listTypeDef)
-            .set('b', booleanType);
-        const flattened = flattenTypeDefsOf(structTypeDef);
-        expect(flattened).toEqual({
-            $: structTypeDef.narrow,
-            '$.a': listTypeDef.narrow,
-            '$.a.*': numberType.narrow,
-            '$.b': booleanType.narrow,
-        });
-    });
-});

package/.out/types/flattened_accessors_of.d.ts

@@ -1,9 +0,0 @@
-import { type Type } from './definitions';
-import { type FlattenedValueTypesOf } from './flattened_value_types_of';
-export type Accessor<T = any> = {
-    readonly value: T;
-    set(v: T): void;
-};
-export type FlattenedAccessorsOf<T extends Type, Flattened extends Readonly<Record<string, Accessor>> = FlattenedValueTypesOf<T>> = {
-    readonly [K in keyof Flattened]: Accessor<Flattened[K]>;
-};

package/.out/types/flattened_value_types_of.d.ts

@@ -1,6 +0,0 @@
-import { type Type } from './definitions';
-import { type FlattenedTypeDefsOf } from './flattened_type_defs_of';
-import { type ValueTypeOf } from './value_type_of';
-export type FlattenedValueTypesOf<T extends Type, SegmentOverride extends string | null = null, Flattened extends Readonly<Record<string, Type>> = FlattenedTypeDefsOf<T, SegmentOverride>> = {
-    [K in keyof Flattened]: ValueTypeOf<Flattened[K], {}>;
-};

package/.out/types/json_path_of.d.ts

@@ -1 +0,0 @@
-export type JsonPathOf<Prefix extends string, Accessor extends string | number | symbol, SegmentOverride extends string | null = null> = SegmentOverride extends string ? `${Prefix}.${SegmentOverride}` : Accessor extends string | number ? `${Prefix}.${Accessor}` : never;

package/.out/types/readonly_type_def_of.d.ts

@@ -1,29 +0,0 @@
-import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
-export type ReadonlyTypeDefOf<T extends Type> = {
-    readonly definition: InternalReadonlyTypeDefOf<T['definition']>;
-};
-type InternalReadonlyTypeDefOf<T extends TypeDef> = T extends LiteralTypeDef ? InternalReadonlyTypeDefOfLiteral<T> : T extends ListTypeDef ? InternalReadonlyTypeDefOfList<T> : T extends RecordTypeDef ? InternalReadonlyTypeDefOfRecord<T> : T extends ObjectTypeDef ? InternalReadonlyTypeDefOfObject<T> : T extends UnionTypeDef ? InternalReadonlyTypeDefOfUnion<T> : never;
-type InternalReadonlyTypeDefOfLiteral<T extends LiteralTypeDef> = T;
-type InternalReadonlyTypeDefOfList<T extends ListTypeDef> = {
-    readonly type: T['type'];
-    readonly elements: InternalReadonlyTypeDefOf<T['elements']>;
-};
-type InternalReadonlyTypeDefOfRecord<T extends RecordTypeDef> = {
-    readonly type: T['type'];
-    readonly keyPrototype: T['keyPrototype'];
-    readonly valueTypeDef: undefined extends T['valueTypeDef'] ? InternalReadonlyTypeDefOf<Exclude<T['valueTypeDef'], undefined>> | undefined : InternalReadonlyTypeDefOf<T['valueTypeDef']>;
-};
-type InternalReadonlyTypeDefOfObject<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
-    readonly type: T['type'];
-    readonly fields: {
-        readonly [K in keyof Fields]: InternalReadonlyTypeDefOf<Fields[K]>;
-    };
-} : never;
-type InternalReadonlyTypeDefOfUnion<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
-    readonly type: T['type'];
-    readonly discriminator: D;
-    readonly unions: {
-        readonly [K in keyof Unions]: InternalReadonlyTypeDefOf<Unions[K]>;
-    };
-} : never;
-export {};

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

@@ -1,11 +0,0 @@
-import { numberType, record, } from 'types/builders';
-describe('FlattenedValueTypesOf', function () {
-    // note we only test a small example since most of the work is done in flatten
-    describe('record', function () {
-        const builder = record(numberType);
-        let v;
-        it('equals expected type', function () {
-            expectTypeOf(v).toEqualTypeOf();
-        });
-    });
-});

package/.out/types/value_type_of.d.ts

@@ -1,24 +0,0 @@
-import { type IsFieldReadonly } from '@strictly/base';
-import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
-export type ValueTypeOf<T, Extra = {}> = T extends Type ? InternalValueTypeOf<T['definition'], Extra> : never;
-export type InternalValueTypeOf<F extends TypeDef, Extra> = F extends LiteralTypeDef ? InternalValueTypeOfLiteral<F> : F extends ListTypeDef ? InternalValueTypeOfList<F, Extra> : F extends RecordTypeDef ? InternalValueTypeOfRecord<F, Extra> : F extends ObjectTypeDef ? InternalValueTypeOfObject<F, Extra> : F extends UnionTypeDef ? InternalValueTypeOfUnion<F, Extra> : never;
-type InternalValueTypeOfLiteral<F extends LiteralTypeDef> = F['valuePrototype'][number];
-type InternalValueTypeOfList<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true ? readonly InternalValueTypeOf<F['elements'], Extra>[] & Extra : InternalValueTypeOf<F['elements'], Extra>[] & Extra;
-type InternalValueTypeOfRecord<F extends RecordTypeDef, Extra> = undefined extends F['valueTypeDef'] ? IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
-    readonly [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>;
-} : {
-    [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>;
-} : IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
-    readonly [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>;
-} : {
-    [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>;
-};
-type InternalValueTypeOfObject<F extends ObjectTypeDef, Extra> = F extends ObjectTypeDef<infer Fields> ? {
-    [K in keyof Fields]: InternalValueTypeOf<Fields[K], Extra>;
-} & Extra : never;
-type InternalValueTypeOfUnion<F extends UnionTypeDef, Extra> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
-    [K in keyof U]: InternalValueTypeOf<U[K], Extra> & Readonly<Record<D, K>>;
-}[keyof U] : {
-    [K in keyof U]: InternalValueTypeOf<U[K], Extra>;
-}[keyof U] : never;
-export {};

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

@@ -1,26 +0,0 @@
-import { flattenTypeDefsOf } from 'transformers/flatteners/flatten_type_defs_of'
-import {
-  booleanType,
-  list,
-  numberType,
-  object,
-} from 'types/builders'
-
-describe('flattenTypeDefsOf', function () {
-  it('flattens', function () {
-    const listTypeDef = list(numberType)
-    const structTypeDef = object()
-      .set('a', listTypeDef)
-      .set('b', booleanType)
-    const flattened = flattenTypeDefsOf(
-      structTypeDef,
-    )
-
-    expect(flattened).toEqual({
-      $: structTypeDef.narrow,
-      '$.a': listTypeDef.narrow,
-      '$.a.*': numberType.narrow,
-      '$.b': booleanType.narrow,
-    })
-  })
-})