Esm

examples/collections/array.ts

@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
+import { TSchema, Static } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------

examples/collections/map.ts

@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
+import { TSchema, Static } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------

examples/collections/set.ts

@@ -27,7 +27,7 @@ THE SOFTWARE.
 ---------------------------------------------------------------------------*/
 
 import { TypeCheck, TypeCompiler, ValueError } from '@sinclair/typebox/compiler'
-import { TSchema, Static, TypeBoxError } from '@sinclair/typebox'
+import { TSchema, Static } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // ----------------------------------------------------------------

examples/index.ts

@@ -1,11 +1,40 @@
-import { Static, String, Object, Number } from 'typebox'
+import { TypeSystem } from '@sinclair/typebox/system'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { Value, ValuePointer } from '@sinclair/typebox/value'
+import { Type, TypeGuard, Symbols, Static, TSchema } from '@sinclair/typebox'
 
-const A = Object({
-  x: Number(),
-  y: Number(),
-  z: String(),
+// -----------------------------------------------------------
+// Create: Type
+// -----------------------------------------------------------
+
+const T = Type.Object({
+  x: Type.Number(),
+  y: Type.Number(),
+  z: Type.Number(),
 })
 
-type A = Static<typeof A>
+type T = Static<typeof T>
+
+console.log(T)
+
+// -----------------------------------------------------------
+// Create: Value
+// -----------------------------------------------------------
+
+const V = Value.Create(T)
+
+console.log(V)
+
+// -----------------------------------------------------------
+// Compile: Type
+// -----------------------------------------------------------
+
+const C = TypeCompiler.Compile(T)
+
+console.log(C.Code())
+
+// -----------------------------------------------------------
+// Check: Value
+// -----------------------------------------------------------
 
-console.log(A)
+console.log(C.Check(V))

examples/prototypes/evaluate.ts

@@ -44,7 +44,6 @@ import {
   TTuple, 
   TProperties, 
   TIntersect, 
-  IntersectType, 
   TUnion, 
   TNever 
 } from '@sinclair/typebox'
@@ -75,7 +74,7 @@ export type TEvaluateArray<T extends TSchema[]> =  T extends [infer L, ...infer
   []
 // prettier-ignore
 export type TEvaluate<T extends TSchema> = 
-  T extends TIntersect<infer S>            ? IntersectType.Resolve<TEvaluateIntersectRest<S>> :
+  T extends TIntersect<infer S>            ? TIntersect<TEvaluateIntersectRest<S>> :
   T extends TUnion<infer S>                ? TUnion<TEvaluateArray<S>> :
   T extends TConstructor<infer P, infer R> ? TConstructor<TEvaluateArray<P>, TEvaluate<R>> : 
   T extends TFunction<infer P, infer R>    ? TFunction<TEvaluateArray<P>, TEvaluate<R>> : 

examples/prototypes/index.ts

@@ -26,7 +26,6 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-export * from './const'
 export * from './evaluate'
 export * from './partial-deep'
 export * from './union-enum'

examples/prototypes/partial-deep.ts

@@ -26,17 +26,18 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, AssertRest, AssertType, Evaluate } from '@sinclair/typebox'
+import { TypeGuard, Type, TSchema, TIntersect, TUnion, TObject, TPartial, TProperties, Evaluate } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
 // TDeepPartial
 // -------------------------------------------------------------------------------------
 export type TPartialDeepProperties<T extends TProperties> = {
   [K in keyof T]: TPartial<T[K]>
 }
-export type TPartialDeepRest<T extends TSchema[]> = T extends [infer L, ...infer R]
-  ? [TPartial<AssertType<L>>, ...TPartialDeepRest<AssertRest<R>>]
-  : []
+export type TPartialDeepRest<T extends TSchema[]> = 
+  T extends [infer L extends TSchema, ...infer R extends TSchema[]]
+    ? [TPartial<L>, ...TPartialDeepRest<R>]
+    : []
 export type TPartialDeep<T extends TSchema> = 
   T extends TIntersect<infer S> ? TIntersect<TPartialDeepRest<S>> :
   T extends TUnion<infer S> ? TUnion<TPartialDeepRest<S>> :

examples/prototypes/union-enum.ts

@@ -26,13 +26,13 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeRegistry, Kind, TSchema, SchemaOptions } from '@sinclair/typebox'
+import { TypeRegistry, Symbols, TSchema, SchemaOptions } from '@sinclair/typebox'
 
 // -------------------------------------------------------------------------------------
 // TUnionEnum
 // -------------------------------------------------------------------------------------
 export interface TUnionEnum<T extends (string | number)[]> extends TSchema {
-  [Kind]: 'UnionEnum'
+  [Symbols.Kind]: 'UnionEnum'
   static: T[number]
   enum: T
 }
@@ -45,5 +45,5 @@ export function UnionEnum<T extends (string | number)[]>(values: [...T], options
     return (typeof value === 'string' || typeof value === 'number') && schema.enum.includes(value)
   }
   if (!TypeRegistry.Has('UnionEnum')) TypeRegistry.Set('UnionEnum', UnionEnumCheck)
-  return { ...options, [Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
+  return { ...options, [Symbols.Kind]: 'UnionEnum', enum: values } as TUnionEnum<T>
 }

examples/prototypes/union-oneof.ts

@@ -26,14 +26,14 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 
-import { TypeRegistry, Kind, Static, TSchema, SchemaOptions } from '@sinclair/typebox'
+import { TypeRegistry, Symbols, Static, TSchema, SchemaOptions } from '@sinclair/typebox'
 import { Value } from '@sinclair/typebox/value'
 
 // -------------------------------------------------------------------------------------
 // TUnionOneOf
 // -------------------------------------------------------------------------------------
 export interface TUnionOneOf<T extends TSchema[]> extends TSchema {
-  [Kind]: 'UnionOneOf'
+  [Symbols.Kind]: 'UnionOneOf'
   static: { [K in keyof T]: Static<T[K]> }[number]
   oneOf: T
 }
@@ -46,5 +46,5 @@ export function UnionOneOf<T extends TSchema[]>(oneOf: [...T], options: SchemaOp
     return 1 === schema.oneOf.reduce((acc: number, schema: any) => (Value.Check(schema, value) ? acc + 1 : acc), 0)
   }
   if (!TypeRegistry.Has('UnionOneOf')) TypeRegistry.Set('UnionOneOf', UnionOneOfCheck)
-  return { ...options, [Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
+  return { ...options, [Symbols.Kind]: 'UnionOneOf', oneOf } as TUnionOneOf<T>
 }