@strictly/define 0.0.1

package/types/mobx_value_type_of.ts

@@ -0,0 +1,16 @@
+import {
+  type Type,
+} from './definitions'
+import { type ValueTypeOf } from './value_type_of'
+
+const MOBX_OBSERVABLE_KEY = '___mobx_observable'
+
+export type MobxObservable<T = {}> = {
+  [MOBX_OBSERVABLE_KEY]: true,
+} & T
+
+export type NonMobxObservable<T = {}> = {
+  [MOBX_OBSERVABLE_KEY]?: never,
+} & T
+
+export type MobxValueTypeOf<T extends Type> = ValueTypeOf<T, MobxObservable>

package/types/partial_type_def_of.ts

@@ -0,0 +1,64 @@
+import {
+  type ListTypeDef,
+  type LiteralTypeDef,
+  type ObjectTypeDef,
+  type RecordTypeDef,
+  type Type,
+  type TypeDef,
+  type TypeDefType,
+  type UnionTypeDef,
+} from './definitions'
+
+// converts a type def to have nullable values and partial record fields
+export type PartialTypeDefOf<T extends Type> = {
+  readonly typeDef: InternalPartialAndNullableOf<T['definition']>,
+}
+
+type InternalPartialAndNullableOf<T extends TypeDef> = {
+  readonly type: TypeDefType.Union,
+  readonly discriminator: null,
+  readonly unions: {
+    readonly [0]: InternalPartialOf<T>,
+    readonly [1]: {
+      readonly type: TypeDefType.Literal,
+      readonly valuePrototype: [null],
+    },
+  },
+}
+
+type InternalPartialOf<T extends TypeDef> = T extends LiteralTypeDef ? InternalPartialOfLiteral<T>
+  : T extends ListTypeDef ? InternalPartialOfList<T>
+  : T extends RecordTypeDef ? InternalPartialOfRecord<T>
+  : T extends ObjectTypeDef ? InternalPartialOfObject<T>
+  : T extends UnionTypeDef ? InternalPartialOfUnion<T>
+  : never
+
+type InternalPartialOfLiteral<T extends LiteralTypeDef> = T
+
+type InternalPartialOfList<T extends ListTypeDef> = {
+  readonly type: T['type'],
+  readonly elements: InternalPartialAndNullableOf<T['elements']>,
+}
+
+type InternalPartialOfRecord<T extends RecordTypeDef> = {
+  readonly type: T['type'],
+  readonly keyPrototype: T['keyPrototype'],
+  readonly valueTypeDef: InternalPartialAndNullableOf<T['valueTypeDef']> | undefined,
+}
+
+type InternalPartialOfObject<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: T['type'],
+    readonly fields: {
+      [K in keyof Fields]+?: InternalPartialAndNullableOf<Fields[K]>
+    },
+  }
+  : never
+
+type InternalPartialOfUnion<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
+    readonly type: T['type'],
+    readonly discriminator: D,
+    readonly unions: {
+      [K in keyof Unions]: InternalPartialOf<Unions[K]>
+    },
+  }
+  : never

package/types/readonly_type_def_of.ts

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

package/types/specs/builder.tests.ts

@@ -0,0 +1,295 @@
+import {
+  booleanType,
+  list,
+  nullable,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+import {
+  type TypeDefType,
+} from 'types/definitions'
+
+describe('builder', function () {
+  describe('literal', function () {
+    const { definition: typeDef } = numberType
+
+    it('equals expected type', function () {
+      type C = {
+        readonly type: TypeDefType.Literal,
+        readonly valuePrototype: [number],
+      }
+
+      expectTypeOf(typeDef).toEqualTypeOf<C>()
+    })
+
+    describe('nullable', function () {
+      const { definition: typeDef } = nullable(numberType)
+
+      type C = {
+        readonly type: TypeDefType.Union,
+        readonly discriminator: null,
+        readonly unions: {
+          readonly [0]: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+          readonly [1]: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [null],
+          },
+        },
+      }
+      it('equals expected type', function () {
+        expectTypeOf(typeDef).toEqualTypeOf<C>()
+      })
+    })
+  })
+
+  describe('list', function () {
+    describe('numeric list', function () {
+      describe('mutable', function () {
+        const { definition: typeDef } = list(numberType)
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.List,
+            elements: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+          }
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+    })
+
+    describe('readonly', function () {
+      const { definition: typeDef } = list(numberType).readonly()
+
+      it('equals expected type', function () {
+        type C = {
+          readonly type: TypeDefType.List,
+          readonly elements: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        }
+
+        expectTypeOf(typeDef).toEqualTypeOf<C>()
+      })
+    })
+  })
+
+  describe('record', function () {
+    describe('numeric record', function () {
+      describe('mutable', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType)
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.Record,
+            readonly keyPrototype: 'a' | 'b' | 'c',
+            valueTypeDef: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+          }
+
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+
+      describe('readonly', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonly()
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.Record,
+            readonly keyPrototype: 'a' | 'b' | 'c',
+            readonly valueTypeDef: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+          }
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+
+      describe('partial', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partial()
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.Record,
+            readonly keyPrototype: 'a' | 'b' | 'c',
+            valueTypeDef: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            } | undefined,
+          }
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+
+      describe('partial readonly', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partial().readonly()
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.Record,
+            readonly keyPrototype: 'a' | 'b' | 'c',
+            readonly valueTypeDef: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            } | undefined,
+          }
+
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+
+      describe('readonly partial', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonly().partial()
+
+        it('equals expected type', function () {
+          type C = {
+            readonly type: TypeDefType.Record,
+            readonly keyPrototype: 'a' | 'b' | 'c',
+            readonly valueTypeDef: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            } | undefined,
+          }
+
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
+      })
+    })
+  })
+
+  describe('object', function () {
+    const { definition: typeDef } = object()
+      .set('a', numberType)
+      .setReadonly('b', booleanType)
+      .setOptional('c', stringType)
+      .setReadonlyOptional('d', numberType)
+
+    it('equals expected type', function () {
+      type C = {
+        readonly type: TypeDefType.Object,
+        readonly fields:
+          & {
+            a: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+          }
+          & {
+            readonly b: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [boolean],
+            },
+          }
+          & {
+            c?: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [string],
+            },
+          }
+          & {
+            readonly d?: {
+              readonly type: TypeDefType.Literal,
+              readonly valuePrototype: [number],
+            },
+          },
+      }
+
+      expectTypeOf(typeDef).toEqualTypeOf<C>()
+    })
+  })
+
+  describe('union', function () {
+    describe('literals', function () {
+      const {
+        definition: typeDef,
+      } = union()
+        .add(
+          '1',
+          numberType,
+        )
+        .add(
+          '2',
+          stringType,
+        )
+
+      it('equals expected type', function () {
+        type C = {
+          readonly type: TypeDefType.Union,
+          readonly discriminator: null,
+          readonly unions:
+            & {
+              readonly [1]: {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [number],
+              },
+            }
+            & {
+              readonly [2]: {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [string],
+              },
+            },
+        }
+        expectTypeOf(typeDef).toEqualTypeOf<C>()
+      })
+    })
+
+    describe('objects', function () {
+      const {
+        definition: typeDef,
+      } = union()
+        .add(
+          '1',
+          object().set('a', booleanType),
+        )
+        .add(
+          '2',
+          object().set('b', numberType),
+        )
+
+      it('equals expected type', function () {
+        type C = {
+          readonly type: TypeDefType.Union,
+          readonly discriminator: null,
+          readonly unions:
+            & {
+              readonly [1]: {
+                readonly type: TypeDefType.Object,
+                readonly fields: {
+                  a: {
+                    readonly type: TypeDefType.Literal,
+                    readonly valuePrototype: [boolean],
+                  },
+                },
+              },
+            }
+            & {
+              readonly [2]: {
+                readonly type: TypeDefType.Object,
+                readonly fields: {
+                  b: {
+                    readonly type: TypeDefType.Literal,
+                    readonly valuePrototype: [number],
+                  },
+                },
+              },
+            },
+        }
+        expectTypeOf(typeDef).toEqualTypeOf<C>()
+      })
+    })
+  })
+})

package/types/specs/flattened_accessors_of.tests.ts

@@ -0,0 +1,27 @@
+import {
+  numberType,
+  record,
+} from 'types/builders'
+import { type FlattenedAccessorsOf } from 'types/flattened_accessors_of'
+
+describe('FlattenedAccessorsOf', function () {
+  // note we only test a small example since most of the work is done in flatten
+  describe('record', function () {
+    const builder = record<typeof numberType, string>(numberType)
+    type V = FlattenedAccessorsOf<typeof builder>
+
+    let v: {
+      readonly $: {
+        readonly value: Record<string, number>,
+        set: (v: Record<string, number>) => void,
+      },
+      readonly [_: `$.${string}`]: {
+        readonly value: number,
+        set: (v: number) => void,
+      },
+    }
+    it('equals expected type', function () {
+      expectTypeOf(v).toEqualTypeOf<V>()
+    })
+  })
+})

package/types/specs/flattened_type_defs_of.tests.ts

@@ -0,0 +1,212 @@
+import { type SimplifyDeep } from 'type-fest'
+import {
+  booleanType,
+  list,
+  numberType,
+  object,
+  record,
+  stringType,
+  union,
+} from 'types/builders'
+import { type TypeDefType } from 'types/definitions'
+import { type FlattenedTypeDefsOf } from 'types/flattened_type_defs_of'
+
+describe('FlattenedTypeDefsOf', function () {
+  describe('literal', function () {
+    type T = FlattenedTypeDefsOf<typeof numberType, null>
+
+    let t: {
+      readonly $: {
+        readonly definition: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: [number],
+        },
+      },
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('list', function () {
+    const builder = list(numberType)
+    type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, '*'>>
+
+    let t: {
+      readonly $: SimplifyDeep<typeof builder.narrow>,
+      readonly ['$.*']: {
+        readonly definition: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: [number],
+        },
+      },
+    }
+    it('equals expected type', function () {
+      expectTypeOf(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('record', function () {
+    const builder = record<typeof numberType, 'a' | 'b'>(numberType)
+    type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, '*'>>
+
+    let t: {
+      readonly $: SimplifyDeep<typeof builder.narrow>,
+      readonly ['$.*']: {
+        readonly definition: {
+          readonly type: TypeDefType.Literal,
+          readonly valuePrototype: [number],
+        },
+      },
+    }
+    it('equals expected type', function () {
+      expectTypeOf<typeof t>(t).toEqualTypeOf<T>()
+    })
+  })
+
+  describe('object', function () {
+    describe('simple', function () {
+      const builder = object()
+        .set('a', numberType)
+        .setOptional('b', stringType)
+        .setReadonly('c', booleanType)
+        .setReadonlyOptional('d', stringType)
+      type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, null>>
+
+      let t: {
+        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly ['$.a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+        readonly ['$.b']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [string],
+          },
+        },
+        readonly ['$.c']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [boolean],
+          },
+        },
+        readonly ['$.d']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [string],
+          },
+        },
+      }
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+  })
+})
+
+describe('union', function () {
+  describe('overlapping', function () {
+    describe('non-discriminated', function () {
+      const builder = union()
+        .add('x', object().set('a', booleanType))
+        .add('y', object().set('b', numberType))
+      type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, null>>
+
+      let t: {
+        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly ['$.a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [boolean],
+          },
+        },
+        readonly ['$.b']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('discriminated', function () {
+      const builder = union('x')
+        .add('1', object().set('a', booleanType))
+        .add('2', object().set('a', numberType))
+      type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, null>>
+
+      let t: {
+        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly ['$.1:a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [boolean],
+          },
+        },
+        readonly ['$.2:a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+      }
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+
+    describe('nested discriminated', function () {
+      const builder = union('x')
+        .add(
+          '1',
+          union('y')
+            .add('p', object().set('a', booleanType))
+            .add('q', object().set('a', stringType)),
+        )
+        .add(
+          '2',
+          union('z')
+            .add('r', object().set('b', numberType))
+            .add('s', object().set('c', stringType)),
+        )
+      type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, null>>
+      let t: {
+        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly ['$.1:p:a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [boolean],
+          },
+        },
+        readonly ['$.1:q:a']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [string],
+          },
+        },
+        readonly ['$.2:r:b']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [number],
+          },
+        },
+        readonly ['$.2:s:c']: {
+          readonly definition: {
+            readonly type: TypeDefType.Literal,
+            readonly valuePrototype: [string],
+          },
+        },
+      }
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
+  })
+})

package/types/specs/flattened_value_types_of.tests.ts

@@ -0,0 +1,21 @@
+import {
+  numberType,
+  record,
+} from 'types/builders'
+import { type FlattenedValueTypesOf } from 'types/flattened_value_types_of'
+
+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<typeof numberType, string>(numberType)
+    type V = FlattenedValueTypesOf<typeof builder>
+
+    let v: {
+      readonly $: Record<string, number>,
+      readonly [_: `$.${string}`]: number,
+    }
+    it('equals expected type', function () {
+      expectTypeOf(v).toEqualTypeOf<V>()
+    })
+  })
+})