@strictly/define 0.0.1 → 0.0.2

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

@@ -1,14 +1,60 @@
 import { booleanType, list, nullable, numberType, object, record, stringType, union, } from 'types/builders';
+import { TypeDefType, } from 'types/definitions';
 describe('builder', function () {
     describe('literal', function () {
-        const { definition: typeDef } = numberType;
+        const { definition } = numberType;
         it('equals expected type', function () {
-            expectTypeOf(typeDef).toEqualTypeOf();
+            expectTypeOf(definition).toEqualTypeOf();
+        });
+        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);
             it('equals expected type', function () {
-                expectTypeOf(typeDef).toEqualTypeOf();
+                expectTypeOf(definition).toEqualTypeOf();
+            });
+        });
+        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,
+                });
             });
         });
     });
@@ -21,8 +67,8 @@ describe('builder', function () {
                 });
             });
         });
-        describe('readonly', function () {
-            const { definition: typeDef } = list(numberType).readonly();
+        describe('readonlyElements', function () {
+            const { definition: typeDef } = list(numberType).readonlyElements();
             it('equals expected type', function () {
                 expectTypeOf(typeDef).toEqualTypeOf();
             });
@@ -37,25 +83,27 @@ describe('builder', function () {
                 });
             });
             describe('readonly', function () {
-                const { definition: typeDef } = record(numberType).readonly();
+                const { definition: typeDef } = record(numberType).readonlyKeys();
                 it('equals expected type', function () {
                     expectTypeOf(typeDef).toEqualTypeOf();
                 });
             });
             describe('partial', function () {
-                const { definition: typeDef } = record(numberType).partial();
+                const { definition: typeDef } = record(numberType).partialKeys();
                 it('equals expected type', function () {
                     expectTypeOf(typeDef).toEqualTypeOf();
                 });
             });
-            describe('partial readonly', function () {
-                const { definition: typeDef } = record(numberType).partial().readonly();
+            describe('partial and readonly', function () {
+                const { definition: typeDef } = record(numberType).partialKeys()
+                    .readonlyKeys();
                 it('equals expected type', function () {
                     expectTypeOf(typeDef).toEqualTypeOf();
                 });
             });
-            describe('readonly partial', function () {
-                const { definition: typeDef } = record(numberType).readonly().partial();
+            describe('readonly and partial', function () {
+                const { definition: typeDef } = record(numberType).readonlyKeys()
+                    .partialKeys();
                 it('equals expected type', function () {
                     expectTypeOf(typeDef).toEqualTypeOf();
                 });
@@ -64,10 +112,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 () {
             expectTypeOf(typeDef).toEqualTypeOf();
         });
@@ -75,18 +123,20 @@ describe('builder', function () {
     describe('union', function () {
         describe('literals', function () {
             const { definition: typeDef, } = union()
-                .add('1', numberType)
-                .add('2', stringType);
+                .or('1', numberType)
+                .or('2', stringType);
             it('equals expected type', function () {
                 expectTypeOf(typeDef).toEqualTypeOf();
             });
         });
         describe('objects', function () {
-            const { definition: typeDef, } = union()
-                .add('1', object().set('a', booleanType))
-                .add('2', object().set('b', numberType));
-            it('equals expected type', function () {
-                expectTypeOf(typeDef).toEqualTypeOf();
+            describe('mutable', function () {
+                const { definition: typeDef, } = union()
+                    .or('1', object().field('a', booleanType))
+                    .or('2', object().field('b', numberType));
+                it('equals expected type', function () {
+                    expectTypeOf(typeDef).toEqualTypeOf();
+                });
             });
         });
     });

package/.out/types/specs/{flattened_accessors_of.tests.js → flattened_accessors_of_type.tests.js}

@@ -1,5 +1,5 @@
 import { numberType, record, } from 'types/builders';
-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(numberType);

package/.out/types/specs/{flattened_type_defs_of.tests.js → flattened_types_of_type.tests.js}

@@ -1,5 +1,5 @@
 import { booleanType, list, numberType, object, record, stringType, union, } from 'types/builders';
-describe('FlattenedTypeDefsOf', function () {
+describe('FlattenedTypesOfType', function () {
     describe('literal', function () {
         let t;
         it('equals expected type', function () {
@@ -23,10 +23,17 @@ describe('FlattenedTypeDefsOf', function () {
     describe('object', function () {
         describe('simple', function () {
             const builder = object()
-                .set('a', numberType)
-                .setOptional('b', stringType)
-                .setReadonly('c', booleanType)
-                .setReadonlyOptional('d', stringType);
+                .field('a', numberType)
+                .optionalField('b', stringType)
+                .readonlyField('c', booleanType)
+                .readonlyOptionalField('d', stringType);
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf(t).toEqualTypeOf();
+            });
+        });
+        describe('optional', function () {
+            const builder = object().optionalField('a', stringType);
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();
@@ -38,8 +45,8 @@ 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));
+                .or('x', object().field('a', booleanType))
+                .or('y', object().field('b', numberType));
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();
@@ -47,8 +54,8 @@ describe('union', function () {
         });
         describe('discriminated', function () {
             const builder = union('x')
-                .add('1', object().set('a', booleanType))
-                .add('2', object().set('a', numberType));
+                .or('1', object().field('a', booleanType))
+                .or('2', object().field('a', numberType));
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();
@@ -56,12 +63,12 @@ describe('union', function () {
         });
         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)));
+                .or('1', union('y')
+                .or('p', object().field('a', booleanType))
+                .or('q', object().field('a', stringType)))
+                .or('2', union('z')
+                .or('r', object().field('b', numberType))
+                .or('s', object().field('c', stringType)));
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();

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

@@ -0,0 +1,24 @@
+import { list, numberType, } from 'types/builders';
+describe('FlattenedValidatorsOfValidatingType', function () {
+    describe('literal', function () {
+        const literalType = numberType.enforce(function () {
+            return 'a';
+        });
+        let t;
+        it('equals expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+    describe('list', function () {
+        const literalType = numberType.enforce(function () {
+            return 'x';
+        });
+        const listType = list(literalType.narrow).enforce(function () {
+            return 'y';
+        });
+        let t;
+        it('equals expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+});

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

@@ -0,0 +1,18 @@
+import { numberType, object, record, stringType, } from 'types/builders';
+describe('FlattenedValuesOfType', 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();
+        });
+    });
+    describe('object', function () {
+        const builder = object().optionalField('a', stringType);
+        let v;
+        it('equals expected type', function () {
+            expectTypeOf(v).toEqualTypeOf();
+        });
+    });
+});

package/.out/types/specs/{partial_type_def_of.tests.js → partial_type_of_type.tests.js}

@@ -22,8 +22,8 @@ describe('PartialTypeDefOf', function () {
     });
     describe('object', function () {
         const builder = object()
-            .set('a', numberType)
-            .setReadonly('b', stringType);
+            .field('a', numberType)
+            .readonlyField('b', stringType);
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();
@@ -32,8 +32,8 @@ describe('PartialTypeDefOf', function () {
     describe('union', function () {
         describe('simple', function () {
             const builder = union()
-                .add('1', numberType)
-                .add('2', stringType);
+                .or('1', numberType)
+                .or('2', stringType);
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();

package/.out/types/specs/{json_paths_of.tests.js → paths_of_type.tests.js}

@@ -1,5 +1,5 @@
 import { booleanType, list, nullable, numberType, object, record, stringType, union, } from 'types/builders';
-describe('JsonPathsOf', function () {
+describe('PathsOfType', function () {
     describe('literal', function () {
         let path;
         describe('regular', function () {
@@ -71,7 +71,7 @@ describe('JsonPathsOf', function () {
             });
         });
         describe('partial', function () {
-            const builder = record(stringType).partial();
+            const builder = record(stringType).partialKeys();
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
             });
@@ -93,9 +93,9 @@ describe('JsonPathsOf', function () {
     describe('object', function () {
         describe('simple', function () {
             const builder = object()
-                .set('n', numberType)
-                .set('b', booleanType)
-                .set('s', stringType);
+                .field('n', numberType)
+                .field('b', booleanType)
+                .field('s', stringType);
             let path;
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
@@ -114,8 +114,8 @@ describe('JsonPathsOf', function () {
         });
         describe('nested', function () {
             const builder = object()
-                .set('s1', object().set('a1', booleanType))
-                .set('s2', object().set('a2', stringType));
+                .field('s1', object().field('a1', booleanType))
+                .field('s2', object().field('a2', stringType));
             let path;
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
@@ -123,7 +123,7 @@ describe('JsonPathsOf', function () {
         });
         describe('object of list', function () {
             const builder = object()
-                .set('l', list(numberType));
+                .field('l', list(numberType));
             describe('no override', function () {
                 let path;
                 it('equals expected type', function () {
@@ -141,8 +141,8 @@ describe('JsonPathsOf', function () {
     describe('union', function () {
         describe('with primitives', function () {
             const builder = union()
-                .add('1', numberType)
-                .add('2', stringType);
+                .or('1', numberType)
+                .or('2', stringType);
             let path;
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
@@ -150,9 +150,9 @@ describe('JsonPathsOf', function () {
         });
         describe('with overlapping record', function () {
             const builder = union()
-                .add('1', object().set('a', numberType).set('b', stringType))
-                .add('2', object().set('b', stringType).set('c', stringType))
-                .add('3', object().set('c', stringType).set('a', stringType));
+                .or('1', object().field('a', numberType).field('b', stringType))
+                .or('2', object().field('b', stringType).field('c', stringType))
+                .or('3', object().field('c', stringType).field('a', stringType));
             let path;
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
@@ -160,8 +160,8 @@ describe('JsonPathsOf', function () {
         });
         describe('nested', function () {
             const builder = union()
-                .add('1', object().set('a', union().add('x', object().set('aa', stringType))))
-                .add('2', object().set('b', union().add('y', object().set('bb', stringType))));
+                .or('1', object().field('a', union().or('x', object().field('aa', stringType))))
+                .or('2', object().field('b', union().or('y', object().field('bb', stringType))));
             let path;
             it('equals expected type', function () {
                 expectTypeOf(path).toEqualTypeOf();
@@ -170,8 +170,8 @@ describe('JsonPathsOf', function () {
     });
     describe('with discriminator', function () {
         const builder = union('x')
-            .add('1', object().set('a', booleanType))
-            .add('2', object().set('b', numberType));
+            .or('1', object().field('a', booleanType))
+            .or('2', object().field('b', numberType));
         let path;
         it('equals expected type', function () {
             expectTypeOf(path).toEqualTypeOf();
@@ -179,8 +179,8 @@ describe('JsonPathsOf', function () {
     });
     describe('with nested discriminator', function () {
         const builder = union('x')
-            .add('1', union('y').add('p', object().set('a', booleanType)))
-            .add('2', union('z').add('q', object().set('b', numberType)));
+            .or('1', union('y').or('p', object().field('a', booleanType)))
+            .or('2', union('z').or('q', object().field('b', numberType)));
         let path;
         it('equals expected type', function () {
             expectTypeOf(path).toEqualTypeOf();

package/.out/types/specs/{readonly_type_def_of.tests.js → readonly_type_of_type.tests.js}

@@ -22,8 +22,8 @@ describe('ReadonlyTypeDefOf', function () {
     });
     describe('object', function () {
         const builder = object()
-            .set('a', numberType)
-            .setOptional('b', stringType);
+            .field('a', numberType)
+            .optionalField('b', stringType);
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();
@@ -31,22 +31,22 @@ describe('ReadonlyTypeDefOf', function () {
     });
     describe('union', function () {
         const builder = union()
-            .add('1', record(numberType))
-            .add('2', stringType);
+            .or('1', record(numberType))
+            .or('2', stringType);
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();
         });
     });
     describe('partial', function () {
-        const builder = record(numberType).partial();
+        const builder = record(numberType).partialKeys();
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();
         });
     });
     describe('readonly', function () {
-        const builder = record(numberType).readonly();
+        const builder = record(numberType).readonlyKeys();
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();

package/.out/types/specs/type_of_type.tests.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,27 @@
+import { list, numberType, } from 'types/builders';
+describe('TypeOfType', function () {
+    describe('literal', function () {
+        const literalType = numberType;
+        let t;
+        it('equals expected type', function () {
+            expectTypeOf().toEqualTypeOf(t);
+        });
+    });
+    describe('list', function () {
+        describe('mutable', function () {
+            const listType = list(numberType);
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf().toEqualTypeOf(t);
+            });
+        });
+        describe('readonly', function () {
+            const listType = list(numberType).readonlyElements();
+            let t;
+            it('equals expected type', function () {
+                expectTypeOf().toEqualTypeOf(t);
+            });
+        });
+    });
+    // TODO other types
+});

package/.out/types/specs/value_of_type.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/types/specs/{value_type_of.tests.js → value_of_type.tests.js}

@@ -1,4 +1,4 @@
-describe('ValueTypeOf', function () {
+describe('ValueOfType', function () {
     describe('literal', function () {
         let t;
         it('equals expected type', function () {

package/.out/types/specs/value_to_type_paths_of_type.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/types/specs/{value_to_type_paths_of.tests.js → value_to_type_paths_of_type.tests.js}

@@ -1,5 +1,5 @@
 import { booleanType, list, nullable, numberType, object, record, stringType, union, } from 'types/builders';
-describe('FlattenedJsonPathsOf', function () {
+describe('ValueToTypePathsOfType', function () {
     describe('literal', function () {
         let t;
         it('equals expected type', function () {
@@ -26,10 +26,10 @@ describe('FlattenedJsonPathsOf', function () {
     });
     describe('object', function () {
         const builder = object()
-            .set('a', list(numberType))
-            .setOptional('b', booleanType)
-            .setReadonly('c', stringType)
-            .setReadonlyOptional('d', stringType);
+            .field('a', list(numberType))
+            .optionalField('b', booleanType)
+            .readonlyField('c', stringType)
+            .readonlyOptionalField('d', stringType);
         let t;
         it('equals expected type', function () {
             expectTypeOf(t).toEqualTypeOf();
@@ -44,8 +44,8 @@ describe('FlattenedJsonPathsOf', function () {
     describe('union', function () {
         describe('non-discriminated', function () {
             const builder = union()
-                .add('1', list(numberType))
-                .add('2', stringType);
+                .or('1', list(numberType))
+                .or('2', stringType);
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();
@@ -53,8 +53,8 @@ describe('FlattenedJsonPathsOf', function () {
         });
         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));
+                .or('1', object().field('a', booleanType).field('b', numberType))
+                .or('2', object().field('x', numberType).field('y', stringType));
             let t;
             it('equals expected type', function () {
                 expectTypeOf(t).toEqualTypeOf();

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

@@ -2,8 +2,8 @@ import { booleanType, numberType, object, union, } from 'types/builders';
 describe('ValueTypesOfDiscriminatedUnion', function () {
     it('matches expected type', function () {
         const { definition } = union('d')
-            .add('a', object().set('x', numberType))
-            .add('b', object().set('y', booleanType));
+            .or('a', object().field('x', numberType))
+            .or('b', object().field('y', booleanType));
         expectTypeOf().toEqualTypeOf();
     });
 });

package/.out/types/strict_definitions.d.ts

@@ -18,10 +18,10 @@ export type StrictRecordTypeDef<K extends RecordKeyType = RecordKeyType, V exten
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
 };
-export type StrictStructuredTypeDefFields = {
+export type StrictObjectTypeDefFields = {
     [Key: ObjectFieldKey]: AnyTypeDef;
 };
-export type StrictObjectTypeDef<Fields extends StrictStructuredTypeDefFields = StrictStructuredTypeDefFields> = {
+export type StrictObjectTypeDef<Fields extends StrictObjectTypeDefFields = StrictObjectTypeDefFields> = {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
 };

package/.out/types/type_of_type.d.ts

@@ -0,0 +1,49 @@
+import { type IsFieldReadonly } from '@strictly/base';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectFieldKey, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, TypeDefType, type UnionTypeDef } from 'types/definitions';
+export type TypeOfType<T extends Type> = T extends Type<infer D> ? {
+    readonly definition: TypeDefOfTypeDef<D>;
+} : never;
+type TypeDefOfTypeDef<D extends TypeDef> = D extends LiteralTypeDef ? TypeDefOfLiteralTypeDef<D> : D extends ListTypeDef ? TypeDefOfListTypeDef<D> : D extends RecordTypeDef ? TypeDefOfRecordTypeDef<D> : D extends ObjectTypeDef ? TypeDefOfObjectTypeDef<D> : D extends UnionTypeDef ? TypeDefOfUnionTypeDef<D> : never;
+type TypeDefOfLiteralTypeDef<T extends LiteralTypeDef> = T extends LiteralTypeDef<infer V> ? {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+} : never;
+type TypeDefOfListTypeDef<T extends ListTypeDef> = T extends ListTypeDef<infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+    readonly type: TypeDefType.List;
+    readonly elements: TypeDefOfTypeDef<E>;
+} : {
+    readonly type: TypeDefType.List;
+    elements: TypeDefOfTypeDef<E>;
+} : never;
+type TypeDefOfRecordTypeDef<T extends RecordTypeDef> = T extends RecordTypeDef<infer K, infer V> ? undefined extends V ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined;
+} : IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>;
+} : never;
+type TypeDefOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: TypeDefType.Object;
+    readonly fields: {
+        [K in keyof Fields as K extends ObjectFieldKey ? K : never]: TypeDefOfTypeDef<NonNullable<Fields[K]>>;
+    };
+} : never;
+type TypeDefOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer U> ? {
+    readonly type: TypeDefType.Union;
+    readonly discriminator: D;
+    readonly unions: {
+        [K in keyof U]: TypeDefOfTypeDef<U[K]>;
+    };
+} : never;
+export declare function typeOfType<T extends Type>({ definition }: T): TypeOfType<T>;
+export {};