@strictly/define 0.0.1 → 0.0.2

package/types/specs/builder.tests.ts

@@ -9,24 +9,38 @@ import {
   union,
 } from 'types/builders'
 import {
-  type TypeDefType,
+  TypeDefType,
 } from 'types/definitions'
+import { type Rule } from 'types/validating_definitions'
 
 describe('builder', function () {
   describe('literal', function () {
-    const { definition: typeDef } = numberType
+    const { definition } = numberType
 
     it('equals expected type', function () {
       type C = {
         readonly type: TypeDefType.Literal,
         readonly valuePrototype: [number],
+        readonly rule: Rule<never>,
+        readonly required: boolean,
+        readonly readonly: boolean,
       }
 
-      expectTypeOf(typeDef).toEqualTypeOf<C>()
+      expectTypeOf(definition).toEqualTypeOf<C>()
+    })
+
+    it('equals expected value', function () {
+      expect(definition).toEqual({
+        type: TypeDefType.Literal,
+        valuePrototype: undefined,
+        rule: expect.anything(),
+        required: false,
+        readonly: false,
+      })
     })
 
     describe('nullable', function () {
-      const { definition: typeDef } = nullable(numberType)
+      const { definition } = nullable(numberType)
 
       type C = {
         readonly type: TypeDefType.Union,
@@ -35,15 +49,67 @@ describe('builder', function () {
           readonly [0]: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [number],
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           },
           readonly [1]: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [null],
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           },
         },
+        readonly rule: Rule<never>,
+        readonly required: boolean,
+        readonly readonly: boolean,
       }
+
       it('equals expected type', function () {
-        expectTypeOf(typeDef).toEqualTypeOf<C>()
+        expectTypeOf(definition).toEqualTypeOf<C>()
+      })
+    })
+
+    describe('required', function () {
+      const { definition } = numberType.required()
+
+      it('equals expected value', function () {
+        expect(definition).toEqual({
+          type: TypeDefType.Literal,
+          valuePrototype: undefined,
+          rule: expect.anything(),
+          required: true,
+          readonly: false,
+        })
+      })
+    })
+
+    describe('readonly', function () {
+      const { definition } = numberType.readonly()
+
+      it('equals expected value', function () {
+        expect(definition).toEqual({
+          type: TypeDefType.Literal,
+          valuePrototype: undefined,
+          rule: expect.anything(),
+          required: false,
+          readonly: true,
+        })
+      })
+    })
+
+    describe('readonly & required', function () {
+      const { definition } = numberType.readonly().required()
+
+      it('equals expected value', function () {
+        expect(definition).toEqual({
+          type: TypeDefType.Literal,
+          valuePrototype: undefined,
+          rule: expect.anything(),
+          required: true,
+          readonly: true,
+        })
       })
     })
   })
@@ -59,15 +125,21 @@ describe('builder', function () {
             elements: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
           expectTypeOf(typeDef).toEqualTypeOf<C>()
         })
       })
     })
 
-    describe('readonly', function () {
-      const { definition: typeDef } = list(numberType).readonly()
+    describe('readonlyElements', function () {
+      const { definition: typeDef } = list(numberType).readonlyElements()
 
       it('equals expected type', function () {
         type C = {
@@ -75,7 +147,13 @@ describe('builder', function () {
           readonly elements: {
             readonly type: TypeDefType.Literal,
             readonly valuePrototype: [number],
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           },
+          readonly rule: Rule<never>,
+          readonly required: boolean,
+          readonly readonly: boolean,
         }
 
         expectTypeOf(typeDef).toEqualTypeOf<C>()
@@ -95,7 +173,13 @@ describe('builder', function () {
             valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
 
           expectTypeOf(typeDef).toEqualTypeOf<C>()
@@ -103,7 +187,7 @@ describe('builder', function () {
       })
 
       describe('readonly', function () {
-        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonly()
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonlyKeys()
 
         it('equals expected type', function () {
           type C = {
@@ -112,14 +196,20 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
           expectTypeOf(typeDef).toEqualTypeOf<C>()
         })
       })
 
       describe('partial', function () {
-        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partial()
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partialKeys()
 
         it('equals expected type', function () {
           type C = {
@@ -128,14 +218,21 @@ describe('builder', function () {
             valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             } | undefined,
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
           expectTypeOf(typeDef).toEqualTypeOf<C>()
         })
       })
 
-      describe('partial readonly', function () {
-        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partial().readonly()
+      describe('partial and readonly', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).partialKeys()
+          .readonlyKeys()
 
         it('equals expected type', function () {
           type C = {
@@ -144,15 +241,22 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             } | undefined,
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
 
           expectTypeOf(typeDef).toEqualTypeOf<C>()
         })
       })
 
-      describe('readonly partial', function () {
-        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonly().partial()
+      describe('readonly and partial', function () {
+        const { definition: typeDef } = record<typeof numberType, 'a' | 'b' | 'c'>(numberType).readonlyKeys()
+          .partialKeys()
 
         it('equals expected type', function () {
           type C = {
@@ -161,7 +265,13 @@ describe('builder', function () {
             readonly valueTypeDef: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             } | undefined,
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
           }
 
           expectTypeOf(typeDef).toEqualTypeOf<C>()
@@ -172,10 +282,10 @@ describe('builder', function () {
 
   describe('object', function () {
     const { definition: typeDef } = object()
-      .set('a', numberType)
-      .setReadonly('b', booleanType)
-      .setOptional('c', stringType)
-      .setReadonlyOptional('d', numberType)
+      .field('a', numberType)
+      .readonlyField('b', booleanType)
+      .optionalField('c', stringType)
+      .readonlyOptionalField('d', numberType)
 
     it('equals expected type', function () {
       type C = {
@@ -185,26 +295,41 @@ describe('builder', function () {
             a: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
           }
           & {
             readonly b: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [boolean],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
           }
           & {
             c?: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [string],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
           }
           & {
             readonly d?: {
               readonly type: TypeDefType.Literal,
               readonly valuePrototype: [number],
+              readonly rule: Rule<never>,
+              readonly required: boolean,
+              readonly readonly: boolean,
             },
           },
+        readonly rule: Rule<never>,
+        readonly required: boolean,
+        readonly readonly: boolean,
       }
 
       expectTypeOf(typeDef).toEqualTypeOf<C>()
@@ -216,11 +341,11 @@ describe('builder', function () {
       const {
         definition: typeDef,
       } = union()
-        .add(
+        .or(
           '1',
           numberType,
         )
-        .add(
+        .or(
           '2',
           stringType,
         )
@@ -234,61 +359,87 @@ describe('builder', function () {
               readonly [1]: {
                 readonly type: TypeDefType.Literal,
                 readonly valuePrototype: [number],
+                readonly rule: Rule<never>,
+                readonly required: boolean,
+                readonly readonly: boolean,
               },
             }
             & {
               readonly [2]: {
                 readonly type: TypeDefType.Literal,
                 readonly valuePrototype: [string],
+                readonly rule: Rule<never>,
+                readonly required: boolean,
+                readonly readonly: boolean,
               },
             },
+          readonly rule: Rule<never>,
+          readonly required: boolean,
+          readonly readonly: boolean,
         }
         expectTypeOf(typeDef).toEqualTypeOf<C>()
       })
     })
 
     describe('objects', function () {
-      const {
-        definition: typeDef,
-      } = union()
-        .add(
-          '1',
-          object().set('a', booleanType),
-        )
-        .add(
-          '2',
-          object().set('b', numberType),
-        )
+      describe('mutable', function () {
+        const {
+          definition: typeDef,
+        } = union()
+          .or(
+            '1',
+            object().field('a', booleanType),
+          )
+          .or(
+            '2',
+            object().field('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],
+        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 rule: Rule<never>,
+                      readonly required: boolean,
+                      readonly readonly: boolean,
+                    },
                   },
+                  readonly rule: Rule<never>,
+                  readonly required: boolean,
+                  readonly readonly: boolean,
                 },
-              },
-            }
-            & {
-              readonly [2]: {
-                readonly type: TypeDefType.Object,
-                readonly fields: {
-                  b: {
-                    readonly type: TypeDefType.Literal,
-                    readonly valuePrototype: [number],
+              }
+              & {
+                readonly [2]: {
+                  readonly type: TypeDefType.Object,
+                  readonly fields: {
+                    b: {
+                      readonly type: TypeDefType.Literal,
+                      readonly valuePrototype: [number],
+                      readonly rule: Rule<never>,
+                      readonly required: boolean,
+                      readonly readonly: boolean,
+                    },
                   },
+                  readonly rule: Rule<never>,
+                  readonly required: boolean,
+                  readonly readonly: boolean,
                 },
               },
-            },
-        }
-        expectTypeOf(typeDef).toEqualTypeOf<C>()
+            readonly rule: Rule<never>,
+            readonly required: boolean,
+            readonly readonly: boolean,
+          }
+          expectTypeOf(typeDef).toEqualTypeOf<C>()
+        })
       })
     })
   })

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

@@ -2,13 +2,13 @@ import {
   numberType,
   record,
 } from 'types/builders'
-import { type FlattenedAccessorsOf } from 'types/flattened_accessors_of'
+import { type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type'
 
-describe('FlattenedAccessorsOf', function () {
+describe('FlattenedAccessorsOfType', 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>
+    type V = FlattenedAccessorsOfType<typeof builder>
 
     let v: {
       readonly $: {

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

@@ -9,11 +9,11 @@ import {
   union,
 } from 'types/builders'
 import { type TypeDefType } from 'types/definitions'
-import { type FlattenedTypeDefsOf } from 'types/flattened_type_defs_of'
+import { type FlattenedTypesOfType } from 'types/flattened_types_of_type'
 
-describe('FlattenedTypeDefsOf', function () {
+describe('FlattenedTypesOfType', function () {
   describe('literal', function () {
-    type T = FlattenedTypeDefsOf<typeof numberType, null>
+    type T = FlattenedTypesOfType<typeof numberType._type, null>
 
     let t: {
       readonly $: {
@@ -30,10 +30,10 @@ describe('FlattenedTypeDefsOf', function () {
 
   describe('list', function () {
     const builder = list(numberType)
-    type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, '*'>>
+    type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, '*'>>
 
     let t: {
-      readonly $: SimplifyDeep<typeof builder.narrow>,
+      readonly $: SimplifyDeep<typeof builder._type>,
       readonly ['$.*']: {
         readonly definition: {
           readonly type: TypeDefType.Literal,
@@ -48,10 +48,10 @@ describe('FlattenedTypeDefsOf', function () {
 
   describe('record', function () {
     const builder = record<typeof numberType, 'a' | 'b'>(numberType)
-    type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, '*'>>
+    type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, '*'>>
 
     let t: {
-      readonly $: SimplifyDeep<typeof builder.narrow>,
+      readonly $: SimplifyDeep<typeof builder._type>,
       readonly ['$.*']: {
         readonly definition: {
           readonly type: TypeDefType.Literal,
@@ -67,14 +67,13 @@ describe('FlattenedTypeDefsOf', function () {
   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>>
-
+        .field('a', numberType)
+        .optionalField('b', stringType)
+        .readonlyField('c', booleanType)
+        .readonlyOptionalField('d', stringType)
+      type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
       let t: {
-        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.a']: {
           readonly definition: {
             readonly type: TypeDefType.Literal,
@@ -83,8 +82,18 @@ describe('FlattenedTypeDefsOf', function () {
         },
         readonly ['$.b']: {
           readonly definition: {
-            readonly type: TypeDefType.Literal,
-            readonly valuePrototype: [string],
+            readonly discriminator: null,
+            readonly type: TypeDefType.Union,
+            readonly unions: {
+              readonly '0': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [string],
+              },
+              readonly '1': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [undefined],
+              },
+            },
           },
         },
         readonly ['$.c']: {
@@ -95,8 +104,18 @@ describe('FlattenedTypeDefsOf', function () {
         },
         readonly ['$.d']: {
           readonly definition: {
-            readonly type: TypeDefType.Literal,
-            readonly valuePrototype: [string],
+            readonly discriminator: null,
+            readonly type: TypeDefType.Union,
+            readonly unions: {
+              readonly '0': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [string],
+              },
+              readonly '1': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [undefined],
+              },
+            },
           },
         },
       }
@@ -104,6 +123,35 @@ describe('FlattenedTypeDefsOf', function () {
         expectTypeOf(t).toEqualTypeOf<T>()
       })
     })
+
+    describe('optional', function () {
+      const builder = object().optionalField('a', stringType)
+      type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
+
+      let t: {
+        readonly $: SimplifyDeep<typeof builder._type>,
+        readonly '$.a': {
+          readonly definition: {
+            readonly discriminator: null,
+            readonly type: TypeDefType.Union,
+            readonly unions: {
+              readonly '0': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [string],
+              },
+              readonly '1': {
+                readonly type: TypeDefType.Literal,
+                readonly valuePrototype: [undefined],
+              },
+            },
+          },
+        },
+      }
+
+      it('equals expected type', function () {
+        expectTypeOf(t).toEqualTypeOf<T>()
+      })
+    })
   })
 })
 
@@ -111,12 +159,12 @@ 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>>
+        .or('x', object().field('a', booleanType))
+        .or('y', object().field('b', numberType))
+      type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
 
       let t: {
-        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.a']: {
           readonly definition: {
             readonly type: TypeDefType.Literal,
@@ -138,12 +186,12 @@ describe('union', function () {
 
     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>>
+        .or('1', object().field('a', booleanType))
+        .or('2', object().field('a', numberType))
+      type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
 
       let t: {
-        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.1:a']: {
           readonly definition: {
             readonly type: TypeDefType.Literal,
@@ -164,21 +212,21 @@ describe('union', function () {
 
     describe('nested discriminated', function () {
       const builder = union('x')
-        .add(
+        .or(
           '1',
           union('y')
-            .add('p', object().set('a', booleanType))
-            .add('q', object().set('a', stringType)),
+            .or('p', object().field('a', booleanType))
+            .or('q', object().field('a', stringType)),
         )
-        .add(
+        .or(
           '2',
           union('z')
-            .add('r', object().set('b', numberType))
-            .add('s', object().set('c', stringType)),
+            .or('r', object().field('b', numberType))
+            .or('s', object().field('c', stringType)),
         )
-      type T = SimplifyDeep<FlattenedTypeDefsOf<typeof builder, null>>
+      type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
       let t: {
-        readonly $: SimplifyDeep<typeof builder.narrow>,
+        readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.1:p:a']: {
           readonly definition: {
             readonly type: TypeDefType.Literal,