@strictly/define 0.0.1

package/types/specs/strict_definitions.tests.ts

@@ -0,0 +1,184 @@
+import {
+  type TypeDefType,
+  type UnionTypeDef,
+} from 'types/definitions'
+import {
+  type IsStrictUnion,
+  type StrictUnionTypeDef,
+} from 'types/strict_definitions'
+
+describe('Strict Definitions', function () {
+  describe('IsStrictUnion', function () {
+    it('detects a non-discriminated strict union', function () {
+      type U = {
+        readonly [1]: {
+          type: TypeDefType.Literal,
+          valuePrototype: ['a'],
+        },
+      }
+      type C = IsStrictUnion<U>
+      expectTypeOf<C>().toEqualTypeOf<true>()
+    })
+
+    it('detects a union with a non-literal type', function () {
+      type U = {
+        readonly [1]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = IsStrictUnion<U>
+      expectTypeOf<C>().toEqualTypeOf<false>()
+    })
+
+    it('detects a union with a non-literal type in position 0', function () {
+      type U = {
+        readonly [0]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = IsStrictUnion<U>
+      expectTypeOf<C>().toEqualTypeOf<true>()
+    })
+
+    it('detects a non-discriminated strict union with multiple options and a non-literal type', function () {
+      type U = {
+        readonly [1]: {
+          type: TypeDefType.Literal,
+          valuePrototype: ['a'],
+        },
+        readonly [2]: {
+          type: TypeDefType.Literal,
+          valuePrototype: ['c'],
+        },
+        readonly [0]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = IsStrictUnion<U>
+      expectTypeOf<C>().toEqualTypeOf<true>()
+    })
+  })
+
+  describe('StrictUnion', function () {
+    it('enforces non-strict unions are of type never', function () {
+      type U = {
+        readonly [1]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = StrictUnionTypeDef<null, U>
+      expectTypeOf<C>().toEqualTypeOf<never>()
+    })
+
+    it('allows unions of multiple literal options', function () {
+      type U = {
+        readonly [1]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a'],
+        },
+        readonly [2]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['c'],
+        },
+      }
+      type C = StrictUnionTypeDef<null, U>
+      expectTypeOf<C>().toEqualTypeOf<{
+        readonly type: TypeDefType.Union,
+        readonly discriminator: null,
+        readonly unions: U,
+      }>()
+    })
+
+    it('allows unions of multiple literal options and one complex type', function () {
+      type U = {
+        readonly [1]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a'],
+        },
+        readonly [2]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['c'],
+        },
+        readonly [0]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = StrictUnionTypeDef<null, U>
+      expectTypeOf<C>().toEqualTypeOf<{
+        readonly type: TypeDefType.Union,
+        readonly discriminator: null,
+        readonly unions: U,
+      }>()
+    })
+  })
+
+  describe('assignment', function () {
+    describe('can be assigned to a non-strict equivalent type', function () {
+      type U = {
+        readonly [1]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a'],
+        },
+        readonly [2]: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['c'],
+        },
+        readonly [0]: {
+          type: TypeDefType.List,
+          elements: {
+            type: TypeDefType.Literal,
+            valuePrototype: ['a'],
+          },
+        },
+      }
+      type C = StrictUnionTypeDef<null, U>
+
+      let t: UnionTypeDef<null, U>
+      it('equals type', function () {
+        expectTypeOf(t).toEqualTypeOf<C>()
+      })
+    })
+  })
+
+  describe('cannot be assigned to an invalid non-strict equivalent type', function () {
+    type U = {
+      readonly [2]: {
+        readonly type: TypeDefType.Literal,
+        readonly valuePrototype: ['a'],
+      },
+      readonly [1]: {
+        type: TypeDefType.List,
+        elements: {
+          type: TypeDefType.Literal,
+          valuePrototype: ['a'],
+        },
+      },
+    }
+    type C = StrictUnionTypeDef<null, U>
+
+    let t: UnionTypeDef<null, U>
+    it('equals type', function () {
+      expectTypeOf<C>().not.toMatchTypeOf(t)
+    })
+  })
+})

package/types/specs/value_to_type_paths_of.tests.ts

@@ -0,0 +1,181 @@
+import {
+  type SimplifyDeep,
+  type ValueOf,
+} from 'type-fest'
+import {
+  booleanType,
+  list,
+  nullable,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+import { type FlattenedTypeDefsOf } from 'types/flattened_type_defs_of'
+import { type ValueToTypePathsOf } from 'types/value_to_type_paths_of'
+
+describe('FlattenedJsonPathsOf', function () {
+  describe('literal', function () {
+    type T = ValueToTypePathsOf<typeof numberType>
+
+    let t: {
+      readonly $: '$',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('list', function () {
+    const builder = list(list(numberType))
+    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+    let t: {
+      readonly $: '$',
+      readonly [_: `$.${number}`]: '$.*',
+      readonly [_: `$.${number}.${number}`]: '$.*.*',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('record', function () {
+    const l = list(numberType)
+    const builder = record<typeof l, 'a' | 'b'>(l)
+    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+    let t: {
+      readonly $: '$',
+      readonly [`$.a`]: '$.*',
+      readonly [`$.b`]: '$.*',
+      readonly [_: `$.a.${number}`]: '$.*.*',
+      readonly [_: `$.b.${number}`]: '$.*.*',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+
+    it('allows lookup of type path', function () {
+      expectTypeOf<T['$.a.1']>().toEqualTypeOf<'$.*.*'>()
+    })
+  })
+
+  describe('object', function () {
+    const builder = object()
+      .set('a', list(numberType))
+      .setOptional('b', booleanType)
+      .setReadonly('c', stringType)
+      .setReadonlyOptional('d', stringType)
+    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+    let t: {
+      readonly $: '$',
+      readonly [`$.a`]: '$.a',
+      readonly [`$.b`]: '$.b',
+      readonly [`$.c`]: '$.c',
+      readonly [`$.d`]: '$.d',
+      readonly [_: `$.a.${number}`]: '$.a.*',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+
+    it('has the same value paths', function () {
+      type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+      expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
+    })
+
+    it('has the same type paths', function () {
+      type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+      expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
+    })
+  })
+
+  describe('union', function () {
+    describe('non-discriminated', function () {
+      const builder = union()
+        .add('1', list(numberType))
+        .add('2', stringType)
+      type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+      let t: {
+        readonly $: '$',
+        readonly [_: `$.${number}`]: '$.*',
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('discriminated', function () {
+      const builder = union('d')
+        .add('1', object().set('a', booleanType).set('b', numberType))
+        .add('2', object().set('x', numberType).set('y', stringType))
+      type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+      let t: {
+        readonly $: '$',
+        readonly ['$.1:a']: '$.1:a',
+        readonly ['$.1:b']: '$.1:b',
+        readonly ['$.2:x']: '$.2:x',
+        readonly ['$.2:y']: '$.2:y',
+      }
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+
+      it('has the same value paths', function () {
+        type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+        expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
+      })
+
+      it('has the same type paths', function () {
+        type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+        expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
+      })
+    })
+  })
+
+  describe('readonly', function () {
+    const builder = list(list(numberType)).readonly()
+
+    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+    let t: {
+      readonly $: '$',
+      readonly [_: `$.${number}`]: '$.*',
+      readonly [_: `$.${number}.${number}`]: '$.*.*',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('nullable', function () {
+    const builder = nullable(list(nullable(list(numberType))))
+
+    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+
+    let t: {
+      readonly $: '$',
+      readonly [_: `$.${number}`]: '$.*',
+      readonly [_: `$.${number}.${number}`]: '$.*.*',
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+
+    it('has the same value paths', function () {
+      type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+      expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
+    })
+
+    it('has the same type paths', function () {
+      type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+      expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
+    })
+  })
+})

package/types/specs/value_type_of.tests.ts

@@ -0,0 +1,329 @@
+import { type SimplifyDeep } from 'type-fest'
+import {
+  type TypeDefType,
+} from 'types/definitions'
+import { type ValueTypeOf } from 'types/value_type_of'
+
+describe('ValueTypeOf', function () {
+  describe('literal', function () {
+    type TypeD = {
+      readonly type: TypeDefType.Literal,
+      readonly valuePrototype: ['a' | 'b' | 'c'],
+    }
+    type T = ValueTypeOf<{ definition: TypeD }>
+
+    let t: 'a' | 'b' | 'c'
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('list', function () {
+    describe('simple', function () {
+      type TypeD = {
+        readonly type: TypeDefType.List,
+        elements: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a' | 'b' | 'c'],
+        },
+      }
+      type T = ValueTypeOf<{ definition: TypeD }>
+      describe('mutable', function () {
+        let a: ('a' | 'b' | 'c')[]
+        it('equals expected type', function () {
+          expectTypeOf(a).toEqualTypeOf<T>()
+        })
+      })
+
+      describe('readonly', function () {
+        type R = ValueTypeOf<{
+          definition: {
+            readonly type: TypeDefType.List,
+            readonly elements: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: ['a' | 'b' | 'c'],
+            },
+          },
+        }>
+
+        let a: readonly ('a' | 'b' | 'c')[]
+        it('equals expected type', function () {
+          expectTypeOf(a).toEqualTypeOf<R>()
+        })
+      })
+    })
+  })
+
+  describe('record', function () {
+    type TypeD = {
+      readonly type: TypeDefType.Record,
+      readonly keyPrototype: 'x' | 'y' | 'z',
+      valueTypeDef: {
+        readonly type: TypeDefType.Literal,
+        readonly valuePrototype: ['a' | 'b' | 'c'],
+      },
+    }
+    type T = ValueTypeOf<{ definition: TypeD }>
+
+    describe('mutable', function () {
+      let t: Record<'x' | 'y' | 'z', 'a' | 'b' | 'c'>
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('readonly', function () {
+      type R = ValueTypeOf<{
+        readonly definition: {
+          readonly type: TypeDefType.Record,
+          readonly keyPrototype: 'x' | 'y' | 'z',
+          readonly valueTypeDef: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: ['a' | 'b' | 'c'],
+          },
+        },
+      }>
+      let r: Readonly<Record<'x' | 'y' | 'z', 'a' | 'b' | 'c'>>
+
+      it('equals expected type', function () {
+        expectTypeOf(r).toEqualTypeOf<R>()
+      })
+    })
+
+    describe('partial', function () {
+      type TypeD = {
+        readonly type: TypeDefType.Record,
+        readonly keyPrototype: 'x' | 'y' | 'z',
+        valueTypeDef: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a' | 'b' | 'c'],
+        } | undefined,
+      }
+      type T = ValueTypeOf<{ definition: TypeD }>
+
+      let t: Partial<Record<'x' | 'y' | 'z', 'a' | 'b' | 'c'>>
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('partial readonly', function () {
+      type TypeD = {
+        readonly type: TypeDefType.Record,
+        readonly keyPrototype: 'x' | 'y' | 'z',
+        readonly valueTypeDef: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a' | 'b' | 'c'],
+        } | undefined,
+      }
+      type T = ValueTypeOf<{ definition: TypeD }>
+
+      let t: Partial<Readonly<Record<'x' | 'y' | 'z', 'a' | 'b' | 'c'>>>
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+  })
+
+  describe('object', function () {
+    type TypeD = {
+      readonly type: TypeDefType.Object,
+      fields: {
+        a: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: ['a' | 'b'],
+        },
+        b: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: [number],
+        },
+      },
+    }
+    type T = ValueTypeOf<{ definition: TypeD }>
+
+    describe('mutable', function () {
+      let value: {
+        a: 'a' | 'b',
+        b: number,
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(value).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('readonly', function () {
+      type TypeD = {
+        readonly type: TypeDefType.Object,
+        fields: {
+          readonly a: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: ['a' | 'b'],
+          },
+          readonly b: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+      }
+      type T = ValueTypeOf<{ definition: TypeD }>
+
+      let value: {
+        readonly a: 'a' | 'b',
+        readonly b: number,
+      }
+      it('equals expected type', function () {
+        expectTypeOf(value).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('partial', function () {
+      type TypeD = {
+        readonly type: TypeDefType.Object,
+        readonly fields: {
+          a?: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: ['a' | 'b'],
+          },
+          b?: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+      }
+      type T = ValueTypeOf<{ definition: TypeD }>
+
+      let v: {
+        a?: 'a' | 'b',
+        b?: number,
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(v).toEqualTypeOf<T>()
+      })
+    })
+  })
+
+  describe('union', function () {
+    describe('non-discriminated', function () {
+      type T = ValueTypeOf<{
+        definition: {
+          readonly type: TypeDefType.Union,
+          readonly discriminator: null,
+          readonly unions: {
+            readonly [0]: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [null],
+            },
+            readonly [1]: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+            readonly [2]: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [string],
+            },
+          },
+        },
+      }>
+
+      let t: null | number | string
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('implicitly discriminated', function () {
+      type T = ValueTypeOf<{
+        definition: {
+          readonly type: TypeDefType.Union,
+          readonly discriminator: null,
+          readonly unions: {
+            readonly [0]: {
+              readonly type: TypeDefType.Object,
+              readonly fields: {
+                b: {
+                  readonly type: TypeDefType.Literal,
+                  readonly valuePrototype: [string],
+                },
+                readonly d: {
+                  readonly type: TypeDefType.Literal,
+                  readonly valuePrototype: [1],
+                },
+              },
+            },
+            readonly [1]: {
+              readonly type: TypeDefType.Object,
+              readonly fields: {
+                b: {
+                  readonly type: TypeDefType.Literal,
+                  readonly valuePrototype: [number],
+                },
+                readonly d: {
+                  readonly type: TypeDefType.Literal,
+                  readonly valuePrototype: [2],
+                },
+              },
+            },
+          },
+        },
+      }>
+
+      let t: {
+        readonly d: 1,
+        b: string,
+      } | {
+        readonly d: 2,
+        b: number,
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('explicitly discriminated', function () {
+      type T = SimplifyDeep<
+        ValueTypeOf<{
+          definition: {
+            readonly type: TypeDefType.Union,
+            readonly discriminator: 'd',
+            readonly unions: {
+              readonly [1]: {
+                readonly type: TypeDefType.Object,
+                readonly fields: {
+                  b: {
+                    readonly type: TypeDefType.Literal,
+                    readonly valuePrototype: [string],
+                  },
+                },
+              },
+              readonly [2]: {
+                readonly type: TypeDefType.Object,
+                readonly fields: {
+                  b: {
+                    readonly type: TypeDefType.Literal,
+                    readonly valuePrototype: [number],
+                  },
+                },
+              },
+            },
+          },
+        }>
+      >
+
+      let t: {
+        readonly d: 1,
+        b: string,
+      } | {
+        readonly d: 2,
+        b: number,
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+  })
+})