@strictly/define 0.0.1

package/types/specs/value_types_of_discriminated_union.tests.ts

@@ -0,0 +1,30 @@
+import { type SimplifyDeep } from 'type-fest'
+import {
+  booleanType,
+  numberType,
+  object,
+  union,
+} from 'types/builders'
+import { type ValueTypesOfDiscriminatedUnion } from 'types/value_types_of_discriminated_union'
+
+describe('ValueTypesOfDiscriminatedUnion', function () {
+  it('matches expected type', function () {
+    const { definition } = union('d')
+      .add('a', object().set('x', numberType))
+      .add('b', object().set('y', booleanType))
+    type T = SimplifyDeep<ValueTypesOfDiscriminatedUnion<
+      typeof definition
+    >>
+
+    expectTypeOf<T>().toEqualTypeOf<{
+      readonly a: {
+        d: 'a',
+        x: number,
+      },
+      readonly b: {
+        d: 'b',
+        y: boolean,
+      },
+    }>()
+  })
+})

package/types/strict_definitions.ts

@@ -0,0 +1,107 @@
+import {
+  type IsEqual,
+  type Simplify,
+} from 'type-fest'
+import {
+  type ObjectFieldKey,
+  type RecordKeyType,
+  type TypeDefType,
+  type UnionKey,
+} from './definitions'
+
+// TODO rename to something more descriptive (e.g. introspectable definitions, deterministic
+// definitions, discriminated definitions). Maybe should just replace definitions since most
+// of the supporting types and utilities don't support non-strict definitions anyway
+
+// strict equivalent of type defs, basically just makes it so Union is introspectable
+
+export type StrictType<T extends StrictTypeDef = StrictTypeDef> = {
+  readonly definition: T,
+}
+
+export type StrictTypeDef =
+  | StrictLiteralTypeDef
+  | StrictListTypeDef
+  | StrictRecordTypeDef
+  | StrictObjectTypeDef
+  | StrictUnionTypeDef
+
+// used to avoid TS complaining about circular references
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyTypeDef = any
+
+// literal
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type StrictLiteralTypeDef<V = any> = {
+  readonly type: TypeDefType.Literal,
+  readonly valuePrototype: [V],
+}
+
+// list
+export type StrictListTypeDef<
+  E extends StrictTypeDef = AnyTypeDef,
+> = {
+  readonly type: TypeDefType.List,
+  // readonly is inherited by the output
+  readonly elements: E,
+}
+
+// map
+export type StrictRecordTypeDef<
+  K extends RecordKeyType = RecordKeyType,
+  // if `V` includes `undefined` the map is partial
+  V extends StrictTypeDef | undefined = AnyTypeDef,
+> = {
+  readonly type: TypeDefType.Record,
+  // never actually populate
+  readonly keyPrototype: K,
+  // readonly is inherited by the output
+  readonly valueTypeDef: V,
+}
+
+// structured type
+
+// NOTE we use the `readonly` and `?` (partial) status of these field definitions
+// to describe the same attributes of the fields
+export type StrictStructuredTypeDefFields = {
+  [Key: ObjectFieldKey]: AnyTypeDef,
+}
+
+// NOTE: we cannot collapse this type to
+// `StructuredTypeDef = StructuredTypeDefFields`
+// as we rely on the `fields` field being unique to discriminate between different
+// TypeDefs
+export type StrictObjectTypeDef<
+  Fields extends StrictStructuredTypeDefFields = StrictStructuredTypeDefFields,
+> = {
+  readonly type: TypeDefType.Object,
+  readonly fields: Fields,
+}
+
+export type StrictUnionTypeDef<
+  D extends string | null = string | null,
+  U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>,
+> = D extends null ? IsStrictUnion<U> extends true ? {
+      readonly discriminator: null,
+      readonly type: TypeDefType.Union,
+      readonly unions: U,
+    }
+  : never
+  // TODO enforce the unions are all structs
+  : {
+    readonly discriminator: D,
+    readonly type: TypeDefType.Union,
+    readonly unions: U,
+  }
+
+// tests whether the union is composed of one non-constant value (at ['0']) and the rest
+// constants
+export type IsStrictUnion<U extends Readonly<Record<UnionKey, AnyTypeDef>>> = IsEqual<
+  U,
+  Simplify<{
+    readonly [K in keyof Omit<U, '0'> as U[K] extends StrictLiteralTypeDef ? K : never]: U[K]
+  } & (U extends { readonly ['0']: AnyTypeDef } ? {
+      readonly ['0']: U['0'],
+    }
+    : {})>
+>

package/types/value_to_type_paths_of.ts

@@ -0,0 +1,184 @@
+import {
+  type SimplifyDeep,
+  type UnionToIntersection,
+} from 'type-fest'
+import {
+  type ListTypeDef,
+  type LiteralTypeDef,
+  type ObjectTypeDef,
+  type RecordTypeDef,
+  type TypeDef,
+  type UnionTypeDef,
+} from './definitions'
+import {
+  type Depths,
+  type StartingDepth,
+} from './flattened'
+import { type JsonPathOf } from './json_path_of'
+import { type StrictType } from './strict_definitions'
+
+export type ValueToTypePathsOf<
+  T extends StrictType,
+  SegmentOverride extends string = '*',
+  Path extends string = '$',
+> = SimplifyDeep<InternalFlattenedJsonPathsOf<
+  T['definition'],
+  SegmentOverride,
+  Path,
+  Path,
+  StartingDepth
+>>
+
+type InternalFlattenedJsonPathsOf<
+  T extends TypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  Depth extends number,
+> =
+  & {
+    readonly [K in ValuePath]: TypePath
+  }
+  & InternalFlattenedJsonPathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>
+
+type InternalFlattenedJsonPathsOfChildren<
+  T extends TypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  Qualifier extends string,
+  Depth extends number,
+  NextDepth extends number = Depths[Depth],
+> = NextDepth extends -1 ? never
+  : T extends LiteralTypeDef ? InternalFlattenedJsonPathsOfLiteralChildren
+  : T extends ListTypeDef ? InternalFlattenedJsonPathsOfListChildren<
+      T,
+      SegmentOverride,
+      ValuePath,
+      TypePath,
+      NextDepth
+    >
+  : T extends RecordTypeDef ? InternalFlattenedJsonPathsOfRecordChildren<
+      T,
+      SegmentOverride,
+      ValuePath,
+      TypePath,
+      NextDepth
+    >
+  : T extends ObjectTypeDef ? InternalFlattenedJsonPathsOfObjectChildren<
+      T,
+      SegmentOverride,
+      ValuePath,
+      TypePath,
+      Qualifier,
+      NextDepth
+    >
+  : T extends UnionTypeDef ? InternalFlattenedJsonPathsOfUnionChildren<
+      T,
+      SegmentOverride,
+      ValuePath,
+      TypePath,
+      Qualifier,
+      NextDepth
+    >
+  : never
+
+type InternalFlattenedJsonPathsOfLiteralChildren = {}
+
+type InternalFlattenedJsonPathsOfListChildren<
+  T extends ListTypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  Depth extends number,
+> = InternalFlattenedJsonPathsOf<
+  T['elements'],
+  SegmentOverride,
+  JsonPathOf<ValuePath, number>,
+  JsonPathOf<TypePath, number, SegmentOverride>,
+  Depth
+>
+
+type InternalFlattenedJsonPathsOfRecordChildren<
+  T extends RecordTypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  Depth extends number,
+> = InternalFlattenedJsonPathsOf<
+  T['valueTypeDef'],
+  SegmentOverride,
+  JsonPathOf<ValuePath, T['keyPrototype']>,
+  JsonPathOf<TypePath, T['keyPrototype'], SegmentOverride>,
+  Depth
+>
+
+type InternalFlattenedJsonPathsOfObjectChildren<
+  T extends ObjectTypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  Qualifier extends string,
+  Depth extends number,
+> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<
+      {
+        readonly [K in keyof Fields]-?: InternalFlattenedJsonPathsOf<
+          Exclude<Fields[K], undefined>,
+          SegmentOverride,
+          JsonPathOf<ValuePath, `${Qualifier}${K}`>,
+          JsonPathOf<TypePath, `${Qualifier}${K}`>,
+          Depth
+        >
+      }[keyof Fields]
+    >
+  : never
+  : never
+
+// type InternalFlattenedJsonPathsOfUnionChildren<
+//   T extends UnionTypeDef,
+//   SegmentOverride extends string,
+//   ValuePath extends string,
+//   TypePath extends string,
+//   Depth extends number,
+// > = T extends UnionTypeDef<infer D, infer Unions> ?
+//     & ({
+//       [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<
+//         Unions[K],
+//         SegmentOverride,
+//         ValuePath,
+//         TypePath,
+//         Depth
+//       >
+//     }[keyof Unions])
+//     & (D extends string ? ReadonlyRecord<JsonPathOf<ValuePath, D>, JsonPathOf<TypePath, D>> : {})
+//   : never
+
+type InternalFlattenedJsonPathsOfUnionChildren<
+  T extends UnionTypeDef,
+  SegmentOverride extends string,
+  ValuePath extends string,
+  TypePath extends string,
+  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<
+          Unions[K],
+          SegmentOverride,
+          ValuePath,
+          TypePath,
+          '',
+          Depth
+        >
+      }[keyof Unions]>
+    : UnionToIntersection<{
+      readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<
+        Unions[K],
+        SegmentOverride,
+        ValuePath,
+        TypePath,
+        `${Qualifier}${K}:`,
+        Depth
+      >
+    }[keyof Unions]>
+  : never
+  : never

package/types/value_type_of.ts

@@ -0,0 +1,84 @@
+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']
+  // partial
+  ? IsFieldReadonly<F, 'valueTypeDef'> extends true
+    // readonly
+    ? {
+      readonly [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>
+    }
+  : {
+    [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>
+  }
+  // complete
+  : IsFieldReadonly<F, 'valueTypeDef'> extends true
+  // readonly
+    ? {
+      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

package/types/value_types_of_discriminated_union.ts

@@ -0,0 +1,14 @@
+import { type UnionTypeDef } from './definitions'
+import { type ValueTypeOf } from './value_type_of'
+
+// 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
+      }
+    }
+  : never
+  : never

package/vitest.workspace.ts

@@ -0,0 +1,11 @@
+import { createVitestUserConfig } from '@strictly/support-vite'
+import {
+  defineWorkspace,
+} from 'vitest/config'
+
+import tsconfig from './tsconfig.json'
+
+export default defineWorkspace([
+  '.',
+  createVitestUserConfig(tsconfig),
+] as const)