@sinclair/typebox 0.26.0-dev.5 → 0.26.1

package/compiler/compiler.d.ts

@@ -32,7 +32,7 @@ export declare class TypeCompilerTypeGuardError extends Error {
 /** Compiles Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T, references: Types.TSchema[]): string;
+    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): string;
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
 }

package/compiler/compiler.js

@@ -165,6 +165,23 @@ var TypeCompiler;
         return typeof value === 'string';
     }
     // -------------------------------------------------------------------
+    // Overrides
+    // -------------------------------------------------------------------
+    function IsNumberCheck(value) {
+        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+    }
+    function IsObjectCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+    }
+    function IsRecordCheck(value) {
+        return !index_2.TypeSystem.AllowArrayObjects
+            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
+            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
+    }
+    function IsVoidCheck(value) {
+        return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+    }
+    // -------------------------------------------------------------------
     // Types
     // -------------------------------------------------------------------
     function* Any(schema, references, value) {
@@ -267,9 +284,7 @@ var TypeCompiler;
         yield `${value} === null`;
     }
     function* Number(schema, references, value) {
-        yield `typeof ${value} === 'number'`;
-        if (!index_2.TypeSystem.AllowNaN)
-            yield `Number.isFinite(${value})`;
+        yield IsNumberCheck(value);
         if (IsNumber(schema.multipleOf))
             yield `(${value} % ${schema.multipleOf}) === 0`;
         if (IsNumber(schema.exclusiveMinimum))
@@ -282,14 +297,7 @@ var TypeCompiler;
             yield `${value} <= ${schema.maximum}`;
     }
     function* Object(schema, references, value) {
-        if (!index_2.TypeSystem.AllowArrayObjects) {
-            yield `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))`;
-        }
-        else {
-            yield `(typeof ${value} === 'object' && ${value} !== null)`;
-        }
-        if (!index_2.TypeSystem.AllowArrayObjects)
-            yield `!Array.isArray(${value})`;
+        yield IsObjectCheck(value);
         if (IsNumber(schema.minProperties))
             yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
         if (IsNumber(schema.maxProperties))
@@ -327,9 +335,7 @@ var TypeCompiler;
         yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
     }
     function* Record(schema, references, value) {
-        yield `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
-        if (!index_2.TypeSystem.AllowArrayObjects)
-            yield `!Array.isArray(${value})`;
+        yield IsRecordCheck(value);
         const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
         const local = PushLocal(`new RegExp(/${keyPattern}/)`);
         yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
@@ -397,12 +403,7 @@ var TypeCompiler;
         yield 'true';
     }
     function* Void(schema, references, value) {
-        if (index_2.TypeSystem.AllowVoidNull) {
-            yield `(${value} === undefined || ${value} === null)`;
-        }
-        else {
-            yield `${value} === undefined`;
-        }
+        yield IsVoidCheck(value);
     }
     function* UserDefined(schema, references, value) {
         const schema_key = `schema_key_${state_remote_custom_types.size}`;
@@ -526,7 +527,7 @@ var TypeCompiler;
         return `${locals.join('\n')}\nreturn ${check}`;
     }
     /** Returns the generated assertion code used to validate this type. */
-    function Code(schema, references) {
+    function Code(schema, references = []) {
         if (!Types.TypeGuard.TSchema(schema))
             throw new TypeCompilerTypeGuardError(schema);
         for (const schema of references)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.26.0-dev.5",
+  "version": "0.26.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -4,7 +4,7 @@
 
 <p>JSON Schema Type Builder with Static Type Resolution for TypeScript</p>
 	
-<img src="./typebox.png" />
+<img src="https://github.com/sinclairzx81/typebox/blob/master/typebox.png?raw=true" />
 
 <br />
 <br />
@@ -62,9 +62,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that constructs in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
+TypeBox is a runtime type builder that creates in-memory JSON Schema objects that can be statically inferred as TypeScript types. The schemas produced by this library are designed to match the static type assertion rules of the TypeScript compiler. TypeBox enables one to create a unified type that can be statically checked by TypeScript and runtime asserted using standard JSON Schema validation.
 
-This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST and RPC services to help validate data received over the wire. 
+This library is designed to enable JSON schema to compose with the same flexibility as TypeScript's type system. It can be used as a simple tool to build up complex schemas or integrated into REST or RPC services to help validate data received over the wire. 
 
 License MIT
 
@@ -189,13 +189,13 @@ function receive(value: T) {                         // ... as a Static Type
 
 ## Types
 
-TypeBox types are small JSON schema fragments which can compose into more complex types though function composition. Each fragment is strictly defined to match to the static type checking rules of TypeScript. TypeBox provides a Standard type set which produces standards compliant JSON schema as well as an Extended type set used to define native JavaScript constructs.
+TypeBox types are JSON schema fragments that can be composed into more complex types. Each fragment is structured such that a JSON schema compliant validator can runtime assert a value the same way TypeScript will statically assert a type. TypeBox provides a set of Standard types which are used create JSON schema compliant schematics as well as an Extended type set used to create schematics for constructs native to JavaScript. 
 
 <a name='types-standard'></a>
 
 ### Standard Types
 
-The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema specification.
+The following table lists the Standard TypeBox types. These types are fully compatible with the JSON Schema Draft 6 specification.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -457,17 +457,6 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 │                                │                             │                                │
 │                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const A = Type.Object({        │ type T = {                  │ const T = {                    │
-│    x: Type.Number(),           │   x: number,                │   $id: 'T'                     │
-│    y: Type.Number()            │   y: number                 │   type: 'object',              │
-│ }, { $id: 'T' })               | }                           │   required: ['x', 'y'],        │
-│                                │                             │   properties: {                │
-│ const T = Type.Deref(          │                             │     x: { type: 'number' },     │
-│   Type.Ref(A)                  │                             │     y: { type: 'number' },     │
-│ )                              │                             │   }                            │
-│                                │                             │ }                              │
-│                                │                             │                                │
 └────────────────────────────────┴─────────────────────────────┴────────────────────────────────┘
 ```
 
@@ -475,9 +464,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 
 ### Extended Types
 
-TypeBox provides several extended types that can be used to produce schematics for common JavaScript constructs. These types cannot be used with standard JSON schema validators; but are useful to help frame schematics for RPC interfaces that may receive JSON validated data. Extended types are prefixed with the `[Extended]` doc comment for convenience.
-
-The following lists the supported types
+TypeBox provides several extended types that can be used to produce schematics for common JavaScript constructs. These types can not be used with standard JSON schema validators; but are useful to help frame schematics for RPC interfaces that may receive JSON validated data. Extended types are prefixed with the `[Extended]` doc comment for convenience. The following table lists the supported types.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -570,7 +557,7 @@ The following lists the supported types
 
 ### Modifiers
 
-TypeBox provides property modifier types that allow properties to be mapped with TypeScript `readonly` and `optional`. The following table shows the modifier types and how they map between TypeScript and JSON Schema.
+TypeBox provides modifiers that allow schema properties to be statically inferred as `readonly` or `optional`. The following table shows the supported modifiers and how they map between TypeScript and JSON Schema.
 
 ```typescript
 ┌────────────────────────────────┬─────────────────────────────┬────────────────────────────────┐
@@ -614,7 +601,7 @@ TypeBox provides property modifier types that allow properties to be mapped with
 
 ### Options
 
-You can pass JSON Schema compliant options on the last argument of any type. Option property hints are provided for convenience.
+You can pass JSON Schema options on the last argument of any type. Option hints specific to each type are provided for convenience.
 
 ```typescript
 // String must be an email
@@ -644,7 +631,7 @@ const T = Type.Array(Type.Integer(), {               // const T = {
 
 ### Generic Types
 
-Generic types can be created with generic functions. The following creates a generic `Vector<T>` type. 
+Generic types can be created with generic functions constrained to type `TSchema`. The following creates a generic `Vector<T>` type.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -661,6 +648,12 @@ const NumberVector = Vector(Type.Number())           // const NumberVector = {
                                                      //   }
                                                      // }
 
+type NumberVector = Static<typeof NumberVector>      // type NumberVector = {
+                                                     //   x: number,
+                                                     //   y: number,
+                                                     //   z: number
+                                                     // }
+
 const BooleanVector = Vector(Type.Boolean())         // const BooleanVector = {
                                                      //   type: 'object',
                                                      //   required: ['x', 'y', 'z'],
@@ -670,13 +663,34 @@ const BooleanVector = Vector(Type.Boolean())         // const BooleanVector = {
                                                      //     z: { type: 'boolean' }
                                                      //   }
                                                      // }
+
+type BooleanVector = Static<typeof BooleanVector>    // type BooleanVector = {
+                                                     //   x: boolean,
+                                                     //   y: boolean,
+                                                     //   z: boolean
+                                                     // }
+```
+
+The following creates a generic `Nullable<T>` type.
+
+```typescript
+const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
+
+const T = Nullable(Type.String())                   // const T = {
+                                                    //   anyOf: [
+                                                    //     { type: 'string' },
+                                                    //     { type: 'null' }
+                                                    //   ]
+                                                    // }
+
+type T = Static<typeof T>                           // type T = string | null
 ```
 
 <a name='types-references'></a>
 
 ### Reference Types
 
-Reference types are supported with `Type.Ref(...)`.
+Reference types are supported with `Type.Ref(...)`. The target type must specify a valid `$id`.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
@@ -730,9 +744,9 @@ function test(node: Node) {
 
 ### Conditional Types
 
-Conditional types are supported with `Extends`, `Exclude` and `Extract`. These work the same as in TypeScript.
+Conditional types are supported with `Extends`, `Exclude` and `Extract`.
 
-#### TypeScript
+**TypeScript**
 
 ```typescript
 type T0 = string extends number ? true : false                                                 
@@ -742,7 +756,7 @@ type T1 = Extract<string | number, number>
 type T2 = Exclude<string | number, number>                                                     
 //   ^ string
 ```
-#### TypeBox
+**TypeBox**
 ```typescript
 const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false)) 
 //    ^ TLiteral<false>
@@ -756,7 +770,7 @@ const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number(
 
 ### Unsafe
 
-Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
+Use `Type.Unsafe(...)` to create custom schematics with user defined inference rules.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -766,7 +780,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` type allows for the expression of specific OpenAPI schema representations.
+The `Type.Unsafe(...)` type can be useful to express specific OpenAPI schema representations.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -801,7 +815,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 ### Guards
 
-TypeBox provides a `TypeGuard` module for reflection and type assertion.
+TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 
 ```typescript
 import { Type, TypeGuard } from '@sinclair/typebox'
@@ -818,7 +832,7 @@ if(TypeGuard.TString(T)) {
 
 ### Strict
 
-TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and runtime type reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
+TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are used for type composition and reflection. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -847,7 +861,7 @@ const U = Type.Strict(T)                             // const U = {
 
 ## Values
 
-TypeBox provides an optional utility module that can be used to perform common operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via additional import.
+TypeBox provides an optional utility module that can be used to perform common operations on JavaScript values. This module includes functionality to create, check and cast values from types as well as check equality, clone, diff and patch JavaScript values. This module is provided via optional import.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -1220,33 +1234,33 @@ This benchmark measures compilation performance for varying types. You can revie
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │    1000    │ '    252 ms' │ '      8 ms' │ '   31.50 x' │
-│ Literal_Number             │    1000    │ '    198 ms' │ '      5 ms' │ '   39.60 x' │
-│ Literal_Boolean            │    1000    │ '    183 ms' │ '      6 ms' │ '   30.50 x' │
-│ Primitive_Number           │    1000    │ '    172 ms' │ '     12 ms' │ '   14.33 x' │
-│ Primitive_String           │    1000    │ '    156 ms' │ '     10 ms' │ '   15.60 x' │
-│ Primitive_Boolean          │    1000    │ '    137 ms' │ '     10 ms' │ '   13.70 x' │
-│ Primitive_Null             │    1000    │ '    118 ms' │ '      7 ms' │ '   16.86 x' │
-│ Primitive_RegEx            │    1000    │ '    235 ms' │ '     11 ms' │ '   21.36 x' │
-│ Object_Unconstrained       │    1000    │ '   1183 ms' │ '     39 ms' │ '   30.33 x' │
-│ Object_Constrained         │    1000    │ '   1164 ms' │ '     35 ms' │ '   33.26 x' │
-│ Tuple_Primitive            │    1000    │ '    470 ms' │ '     16 ms' │ '   29.38 x' │
-│ Tuple_Object               │    1000    │ '   1096 ms' │ '     17 ms' │ '   64.47 x' │
-│ Composite_Intersect        │    1000    │ '    570 ms' │ '     21 ms' │ '   27.14 x' │
-│ Composite_Union            │    1000    │ '    523 ms' │ '     21 ms' │ '   24.90 x' │
-│ Math_Vector4               │    1000    │ '    788 ms' │ '     12 ms' │ '   65.67 x' │
-│ Math_Matrix4               │    1000    │ '    389 ms' │ '     12 ms' │ '   32.42 x' │
-│ Array_Primitive_Number     │    1000    │ '    291 ms' │ '      6 ms' │ '   48.50 x' │
-│ Array_Primitive_String     │    1000    │ '    313 ms' │ '      4 ms' │ '   78.25 x' │
-│ Array_Primitive_Boolean    │    1000    │ '    357 ms' │ '      3 ms' │ '  119.00 x' │
-│ Array_Object_Unconstrained │    1000    │ '   1551 ms' │ '     19 ms' │ '   81.63 x' │
-│ Array_Object_Constrained   │    1000    │ '   1258 ms' │ '     20 ms' │ '   62.90 x' │
-│ Array_Tuple_Primitive      │    1000    │ '    951 ms' │ '     15 ms' │ '   63.40 x' │
-│ Array_Tuple_Object         │    1000    │ '   1157 ms' │ '     14 ms' │ '   82.64 x' │
-│ Array_Composite_Intersect  │    1000    │ '    856 ms' │ '     19 ms' │ '   45.05 x' │
-│ Array_Composite_Union      │    1000    │ '   1073 ms' │ '     16 ms' │ '   67.06 x' │
-│ Array_Math_Vector4         │    1000    │ '   1062 ms' │ '     11 ms' │ '   96.55 x' │
-│ Array_Math_Matrix4         │    1000    │ '    478 ms' │ '      6 ms' │ '   79.67 x' │
+│ Literal_String             │    1000    │ '    260 ms' │ '      8 ms' │ '   32.50 x' │
+│ Literal_Number             │    1000    │ '    198 ms' │ '      4 ms' │ '   49.50 x' │
+│ Literal_Boolean            │    1000    │ '    185 ms' │ '      5 ms' │ '   37.00 x' │
+│ Primitive_Number           │    1000    │ '    176 ms' │ '      9 ms' │ '   19.56 x' │
+│ Primitive_String           │    1000    │ '    161 ms' │ '      9 ms' │ '   17.89 x' │
+│ Primitive_String_Pattern   │    1000    │ '    215 ms' │ '     12 ms' │ '   17.92 x' │
+│ Primitive_Boolean          │    1000    │ '    133 ms' │ '      5 ms' │ '   26.60 x' │
+│ Primitive_Null             │    1000    │ '    143 ms' │ '      8 ms' │ '   17.88 x' │
+│ Object_Unconstrained       │    1000    │ '   1181 ms' │ '     38 ms' │ '   31.08 x' │
+│ Object_Constrained         │    1000    │ '   1168 ms' │ '     32 ms' │ '   36.50 x' │
+│ Tuple_Primitive            │    1000    │ '    557 ms' │ '     16 ms' │ '   34.81 x' │
+│ Tuple_Object               │    1000    │ '   1119 ms' │ '     17 ms' │ '   65.82 x' │
+│ Composite_Intersect        │    1000    │ '    569 ms' │ '     22 ms' │ '   25.86 x' │
+│ Composite_Union            │    1000    │ '    513 ms' │ '     23 ms' │ '   22.30 x' │
+│ Math_Vector4               │    1000    │ '    802 ms' │ '     10 ms' │ '   80.20 x' │
+│ Math_Matrix4               │    1000    │ '    395 ms' │ '     12 ms' │ '   32.92 x' │
+│ Array_Primitive_Number     │    1000    │ '    282 ms' │ '      8 ms' │ '   35.25 x' │
+│ Array_Primitive_String     │    1000    │ '    321 ms' │ '      5 ms' │ '   64.20 x' │
+│ Array_Primitive_Boolean    │    1000    │ '    364 ms' │ '      5 ms' │ '   72.80 x' │
+│ Array_Object_Unconstrained │    1000    │ '   1573 ms' │ '     18 ms' │ '   87.39 x' │
+│ Array_Object_Constrained   │    1000    │ '   1270 ms' │ '     20 ms' │ '   63.50 x' │
+│ Array_Tuple_Primitive      │    1000    │ '    973 ms' │ '     18 ms' │ '   54.06 x' │
+│ Array_Tuple_Object         │    1000    │ '   1253 ms' │ '     16 ms' │ '   78.31 x' │
+│ Array_Composite_Intersect  │    1000    │ '    927 ms' │ '     20 ms' │ '   46.35 x' │
+│ Array_Composite_Union      │    1000    │ '   1123 ms' │ '     16 ms' │ '   70.19 x' │
+│ Array_Math_Vector4         │    1000    │ '   1068 ms' │ '     10 ms' │ '  106.80 x' │
+│ Array_Math_Matrix4         │    1000    │ '    488 ms' │ '      7 ms' │ '   69.71 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1260,35 +1274,35 @@ This benchmark measures validation performance for varying types. You can review
 ┌────────────────────────────┬────────────┬──────────────┬──────────────┬──────────────┬──────────────┐
 │          (index)           │ Iterations │  ValueCheck  │     Ajv      │ TypeCompiler │ Performance  │
 ├────────────────────────────┼────────────┼──────────────┼──────────────┼──────────────┼──────────────┤
-│ Literal_String             │  1000000   │ '     24 ms' │ '      6 ms' │ '      5 ms' │ '    1.20 x' │
-│ Literal_Number             │  1000000   │ '     19 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│ Literal_String             │  1000000   │ '     26 ms' │ '      6 ms' │ '      6 ms' │ '    1.00 x' │
+│ Literal_Number             │  1000000   │ '     21 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
 │ Literal_Boolean            │  1000000   │ '     19 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
-│ Primitive_Number           │  1000000   │ '     25 ms' │ '     17 ms' │ '     11 ms' │ '    1.55 x' │
-│ Primitive_String           │  1000000   │ '     23 ms' │ '     16 ms' │ '     10 ms' │ '    1.60 x' │
-│ Primitive_Boolean          │  1000000   │ '     19 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Primitive_Null             │  1000000   │ '     21 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
-│ Primitive_RegEx            │  1000000   │ '    154 ms' │ '     45 ms' │ '     38 ms' │ '    1.18 x' │
-│ Object_Unconstrained       │  1000000   │ '    837 ms' │ '     34 ms' │ '     29 ms' │ '    1.17 x' │
-│ Object_Constrained         │  1000000   │ '   1045 ms' │ '     52 ms' │ '     45 ms' │ '    1.16 x' │
-│ Object_Recursive           │  1000000   │ '   4711 ms' │ '    355 ms' │ '    100 ms' │ '    3.55 x' │
-│ Tuple_Primitive            │  1000000   │ '    163 ms' │ '     21 ms' │ '     16 ms' │ '    1.31 x' │
-│ Tuple_Object               │  1000000   │ '    668 ms' │ '     30 ms' │ '     26 ms' │ '    1.15 x' │
-│ Composite_Intersect        │  1000000   │ '    682 ms' │ '     28 ms' │ '     21 ms' │ '    1.33 x' │
-│ Composite_Union            │  1000000   │ '    463 ms' │ '     22 ms' │ '     19 ms' │ '    1.16 x' │
-│ Math_Vector4               │  1000000   │ '    255 ms' │ '     22 ms' │ '     13 ms' │ '    1.69 x' │
-│ Math_Matrix4               │  1000000   │ '    988 ms' │ '     38 ms' │ '     29 ms' │ '    1.31 x' │
-│ Array_Primitive_Number     │  1000000   │ '    270 ms' │ '     26 ms' │ '     15 ms' │ '    1.73 x' │
-│ Array_Primitive_String     │  1000000   │ '    207 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
-│ Array_Primitive_Boolean    │  1000000   │ '    137 ms' │ '     21 ms' │ '     19 ms' │ '    1.11 x' │
-│ Array_Object_Unconstrained │  1000000   │ '   4698 ms' │ '     68 ms' │ '     61 ms' │ '    1.11 x' │
-│ Array_Object_Constrained   │  1000000   │ '   4863 ms' │ '    139 ms' │ '    117 ms' │ '    1.19 x' │
-│ Array_Object_Recursive     │  1000000   │ '  19170 ms' │ '   1606 ms' │ '    332 ms' │ '    4.84 x' │
-│ Array_Tuple_Primitive      │  1000000   │ '    724 ms' │ '     38 ms' │ '     31 ms' │ '    1.23 x' │
-│ Array_Tuple_Object         │  1000000   │ '   2843 ms' │ '     71 ms' │ '     63 ms' │ '    1.13 x' │
-│ Array_Composite_Intersect  │  1000000   │ '   2816 ms' │ '     49 ms' │ '     40 ms' │ '    1.23 x' │
-│ Array_Composite_Union      │  1000000   │ '   2021 ms' │ '     69 ms' │ '     39 ms' │ '    1.77 x' │
-│ Array_Math_Vector4         │  1000000   │ '   1080 ms' │ '     39 ms' │ '     25 ms' │ '    1.56 x' │
-│ Array_Math_Matrix4         │  1000000   │ '   4561 ms' │ '    112 ms' │ '     96 ms' │ '    1.17 x' │
+│ Primitive_Number           │  1000000   │ '     24 ms' │ '     19 ms' │ '     11 ms' │ '    1.73 x' │
+│ Primitive_String           │  1000000   │ '     26 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_String_Pattern   │  1000000   │ '    159 ms' │ '     45 ms' │ '     37 ms' │ '    1.22 x' │
+│ Primitive_Boolean          │  1000000   │ '     23 ms' │ '     17 ms' │ '     10 ms' │ '    1.70 x' │
+│ Primitive_Null             │  1000000   │ '     23 ms' │ '     18 ms' │ '     10 ms' │ '    1.80 x' │
+│ Object_Unconstrained       │  1000000   │ '    809 ms' │ '     35 ms' │ '     30 ms' │ '    1.17 x' │
+│ Object_Constrained         │  1000000   │ '   1060 ms' │ '     56 ms' │ '     45 ms' │ '    1.24 x' │
+│ Object_Recursive           │  1000000   │ '   4965 ms' │ '    397 ms' │ '    100 ms' │ '    3.97 x' │
+│ Tuple_Primitive            │  1000000   │ '    159 ms' │ '     22 ms' │ '     16 ms' │ '    1.38 x' │
+│ Tuple_Object               │  1000000   │ '    658 ms' │ '     31 ms' │ '     27 ms' │ '    1.15 x' │
+│ Composite_Intersect        │  1000000   │ '    695 ms' │ '     26 ms' │ '     22 ms' │ '    1.18 x' │
+│ Composite_Union            │  1000000   │ '    503 ms' │ '     24 ms' │ '     19 ms' │ '    1.26 x' │
+│ Math_Vector4               │  1000000   │ '    259 ms' │ '     22 ms' │ '     14 ms' │ '    1.57 x' │
+│ Math_Matrix4               │  1000000   │ '   1007 ms' │ '     40 ms' │ '     29 ms' │ '    1.38 x' │
+│ Array_Primitive_Number     │  1000000   │ '    262 ms' │ '     23 ms' │ '     17 ms' │ '    1.35 x' │
+│ Array_Primitive_String     │  1000000   │ '    241 ms' │ '     27 ms' │ '     24 ms' │ '    1.13 x' │
+│ Array_Primitive_Boolean    │  1000000   │ '    141 ms' │ '     23 ms' │ '     20 ms' │ '    1.15 x' │
+│ Array_Object_Unconstrained │  1000000   │ '   4976 ms' │ '     70 ms' │ '     67 ms' │ '    1.04 x' │
+│ Array_Object_Constrained   │  1000000   │ '   5234 ms' │ '    143 ms' │ '    120 ms' │ '    1.19 x' │
+│ Array_Object_Recursive     │  1000000   │ '  19605 ms' │ '   1909 ms' │ '    350 ms' │ '    5.45 x' │
+│ Array_Tuple_Primitive      │  1000000   │ '    706 ms' │ '     39 ms' │ '     32 ms' │ '    1.22 x' │
+│ Array_Tuple_Object         │  1000000   │ '   2951 ms' │ '     67 ms' │ '     63 ms' │ '    1.06 x' │
+│ Array_Composite_Intersect  │  1000000   │ '   2969 ms' │ '     49 ms' │ '     44 ms' │ '    1.11 x' │
+│ Array_Composite_Union      │  1000000   │ '   2191 ms' │ '     77 ms' │ '     41 ms' │ '    1.88 x' │
+│ Array_Math_Vector4         │  1000000   │ '   1164 ms' │ '     41 ms' │ '     25 ms' │ '    1.64 x' │
+│ Array_Math_Matrix4         │  1000000   │ '   4903 ms' │ '    115 ms' │ '     99 ms' │ '    1.16 x' │
 └────────────────────────────┴────────────┴──────────────┴──────────────┴──────────────┴──────────────┘
 ```
 
@@ -1302,10 +1316,10 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '108.2 kb' │ ' 48.5 kb' │  '2.23 x'   │
-│ typebox/errors       │ ' 92.9 kb' │ ' 41.4 kb' │  '2.24 x'   │
-│ typebox/system       │ ' 59.7 kb' │ ' 24.5 kb' │  '2.43 x'   │
-│ typebox/value        │ '153.3 kb' │ ' 66.6 kb' │  '2.30 x'   │
+│ typebox/compiler     │ '108.8 kb' │ ' 48.9 kb' │  '2.23 x'   │
+│ typebox/errors       │ ' 93.2 kb' │ ' 41.5 kb' │  '2.24 x'   │
+│ typebox/system       │ ' 60.0 kb' │ ' 24.6 kb' │  '2.43 x'   │
+│ typebox/value        │ '153.5 kb' │ ' 66.7 kb' │  '2.30 x'   │
 │ typebox              │ ' 58.7 kb' │ ' 24.1 kb' │  '2.43 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```

package/system/system.d.ts

@@ -17,4 +17,8 @@ export declare namespace TypeSystem {
     function Type<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
     /** Creates a new string format */
     function Format<F extends string>(format: F, check: (value: string) => boolean): F;
+    /** @deprecated Use `TypeSystem.Type()` instead. */
+    function CreateType<Type, Options = object>(kind: string, check: (options: Options, value: unknown) => boolean): (options?: Partial<Options>) => Types.TUnsafe<Type>;
+    /** @deprecated Use `TypeSystem.Format()` instead.  */
+    function CreateFormat<F extends string>(format: F, check: (value: string) => boolean): F;
 }

package/system/system.js

@@ -31,13 +31,13 @@ exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDupli
 const Types = require("../typebox");
 class TypeSystemDuplicateTypeKind extends Error {
     constructor(kind) {
-        super(`Duplicate kind '${kind}' detected`);
+        super(`Duplicate type kind '${kind}' detected`);
     }
 }
 exports.TypeSystemDuplicateTypeKind = TypeSystemDuplicateTypeKind;
 class TypeSystemDuplicateFormat extends Error {
     constructor(kind) {
-        super(`Duplicate format '${kind}' detected`);
+        super(`Duplicate string format '${kind}' detected`);
     }
 }
 exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
@@ -66,4 +66,17 @@ var TypeSystem;
         return format;
     }
     TypeSystem.Format = Format;
+    // ------------------------------------------------------------------------
+    // Deprecated
+    // ------------------------------------------------------------------------
+    /** @deprecated Use `TypeSystem.Type()` instead. */
+    function CreateType(kind, check) {
+        return Type(kind, check);
+    }
+    TypeSystem.CreateType = CreateType;
+    /** @deprecated Use `TypeSystem.Format()` instead.  */
+    function CreateFormat(format, check) {
+        return Format(format, check);
+    }
+    TypeSystem.CreateFormat = CreateFormat;
 })(TypeSystem = exports.TypeSystem || (exports.TypeSystem = {}));

package/typebox.d.ts

@@ -84,13 +84,15 @@ export interface TBoolean extends TSchema {
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
 export type TCompositeUnion<Left extends TSchema, Right extends TSchema> = Ensure<TUnion<[Left, Right]>>;
-export type TCompositeMerge<T extends TObject, Output extends Record<any, TSchema>> = Evaluate<{
-    [Key in keyof T['properties']]: Key extends keyof Output ? TCompositeUnion<T['properties'][Key], Output[Key]> : T['properties'][Key];
-} & {
-    [Key in keyof Output]: Key extends keyof T['properties'] ? TCompositeUnion<T['properties'][Key], Output[Key]> : Output[Key];
-}>;
-export type TCompositeReduce<T extends TObject[], Output extends {}> = T extends [infer L, ...infer R] ? TCompositeReduce<[...Assert<R, TObject[]>], TCompositeMerge<Assert<L, TObject>, Output>> : T extends [] ? Output : never;
-export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeReduce<T, {}>>>;
+export type TCompositeUnionLeft<T extends TObject, Acc extends TProperties> = {
+    [K in keyof T['properties']]: K extends keyof Acc ? TCompositeUnion<T['properties'][K], Acc[K]> : T['properties'][K];
+};
+export type TCompositeUnionRight<T extends TObject, Acc extends TProperties> = {
+    [K in keyof Acc]: K extends keyof T['properties'] ? TCompositeUnion<T['properties'][K], Acc[K]> : Acc[K];
+};
+export type TCompositeUnionObject<T extends TObject, Acc extends TProperties> = Evaluate<TCompositeUnionLeft<T, Acc> & TCompositeUnionRight<T, Acc>>;
+export type TCompositeProperties<T extends TObject[], Acc extends TProperties> = T extends [...infer L, infer R] ? TCompositeProperties<Assert<L, TObject[]>, TCompositeUnionObject<Assert<R, TObject>, Acc>> : T extends [] ? Acc : never;
+export type TComposite<T extends TObject[] = TObject[]> = Ensure<TObject<TCompositeProperties<T, {}>>>;
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<Assert<T[K], TSchema>, P>;
 }];
@@ -382,11 +384,12 @@ export interface TVoid extends TSchema {
     type: 'null';
     typeOf: 'Void';
 }
-/** Creates a static type from a TypeBox type */
+/** Creates a TypeScript static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
 export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** A registry for user defined types */
 export declare namespace TypeRegistry {
     /** Returns the entries in this registry */
     function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
@@ -400,7 +403,7 @@ export declare namespace TypeRegistry {
     function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;
 }
 export type FormatRegistryValidationFunction = (value: string) => boolean;
-/** Provides functions to create user defined string formats */
+/** A registry for user defined string formats */
 export declare namespace FormatRegistry {
     /** Returns the entries in this registry */
     function Entries(): Map<string, FormatRegistryValidationFunction>;
@@ -417,6 +420,7 @@ export declare class TypeGuardUnknownTypeError extends Error {
     readonly schema: unknown;
     constructor(schema: unknown);
 }
+/** Provides functions to test if JavaScript values are TypeBox types */
 export declare namespace TypeGuard {
     /** Returns true if the given schema is TAny */
     function TAny(schema: unknown): schema is TAny;
@@ -499,7 +503,7 @@ export declare namespace TypeExtends {
 }
 /** Specialized Clone for Types */
 export declare namespace TypeClone {
-    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    /** Clones a type. */
     function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
 export declare namespace ObjectMap {
@@ -527,9 +531,7 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Array<T extends TSchema>(items: T, options?: ArrayOptions): TArray<T>;
     /** `[Standard]` Creates a Boolean type */
     Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
-    Composite<T extends TIntersect<TObject[]>>(schema: T, options?: ObjectOptions): TComposite<T['allOf']>;
-    /** `[Standard]` Creates a Composite object type that will Union any overlapping properties of the given Object array */
+    /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
     Composite<T extends TObject[]>(schemas: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Standard]` Creates a Enum type */
     Enum<T extends Record<string, string | number>>(item: T, options?: SchemaOptions): TEnum<T>;
@@ -537,7 +539,7 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
     /** `[Standard]` Excludes from the left type any type that is not assignable to the right */
     Exclude<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;

package/typebox.js

@@ -34,6 +34,7 @@ exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.Stan
 exports.Modifier = Symbol.for('TypeBox.Modifier');
 exports.Hint = Symbol.for('TypeBox.Hint');
 exports.Kind = Symbol.for('TypeBox.Kind');
+/** A registry for user defined types */
 var TypeRegistry;
 (function (TypeRegistry) {
     const map = new Map();
@@ -63,7 +64,7 @@ var TypeRegistry;
     }
     TypeRegistry.Get = Get;
 })(TypeRegistry = exports.TypeRegistry || (exports.TypeRegistry = {}));
-/** Provides functions to create user defined string formats */
+/** A registry for user defined string formats */
 var FormatRegistry;
 (function (FormatRegistry) {
     const map = new Map();
@@ -103,6 +104,7 @@ class TypeGuardUnknownTypeError extends Error {
     }
 }
 exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+/** Provides functions to test if JavaScript values are TypeBox types */
 var TypeGuard;
 (function (TypeGuard) {
     function IsObject(value) {
@@ -1345,7 +1347,7 @@ var TypeClone;
             return Object(value);
         return value;
     }
-    /** Clones a type. This function will omit non-self referential identifiers on the cloned type. */
+    /** Clones a type. */
     function Clone(schema, options) {
         return { ...Visit(schema), ...options };
     }
@@ -1463,20 +1465,12 @@ class StandardTypeBuilder extends TypeBuilder {
     Boolean(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Boolean', type: 'boolean' });
     }
-    Composite(unresolved, options = {}) {
-        const schemas = TypeGuard.TIntersect(unresolved) ? unresolved.allOf : unresolved;
-        const optional = new Set();
-        for (const schema of schemas) {
-            for (const [key, property] of globalThis.Object.entries(schema.properties)) {
-                if (TypeGuard.TOptional(property) || TypeGuard.TReadonlyOptional(property))
-                    optional.add(key);
-            }
-        }
+    /** `[Standard]` Creates a Composite object type that will union any overlapping properties of the given object array */
+    Composite(schemas, options) {
         const properties = {};
         for (const object of schemas) {
             for (const [key, property] of globalThis.Object.entries(object.properties)) {
-                const mapped = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
-                properties[key] = optional.has(key) ? this.Optional(mapped) : mapped;
+                properties[key] = key in properties ? this.Union([properties[key], property]) : TypeClone.Clone(property, {});
             }
         }
         return this.Object(properties, options);
@@ -1509,7 +1503,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return (TypeExtends.Extends(left, right) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Clone(left, options));
         }
     }
-    /** `[Standard]` Extracts from left left any type that is assignable to the right */
+    /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract(left, right, options = {}) {
         if (TypeGuard.TUnion(left)) {
             const narrowed = left.anyOf.filter((inner) => TypeExtends.Extends(inner, right) !== TypeExtendsResult.False);

package/value/check.js

@@ -237,10 +237,10 @@ var ValueCheck;
         if (!IsObject(value)) {
             return false;
         }
-        if (IsNumber(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+        if (IsDefined(schema.minProperties) && !(globalThis.Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
             return false;
         }
-        if (IsNumber(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+        if (IsDefined(schema.maxProperties) && !(globalThis.Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
             return false;
         }
         const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);

package/value/value.d.ts

@@ -1,5 +1,5 @@
 import * as Types from '../typebox';
-import { ValueError } from '../errors/index';
+import { ValueErrorIterator } from '../errors/index';
 import { Edit } from './delta';
 /** Provides functions to perform structural updates to JavaScript values */
 export declare namespace Value {
@@ -16,15 +16,15 @@ export declare namespace Value {
     /** Returns true if the value matches the given type. */
     function Check<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
     /** Converts any type mismatched values to their target type if a conversion is possible. */
-    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): value is Types.Static<T>;
+    function Convert<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): unknown;
     /** Converts any type mismatched values to their target type if a conversion is possible. */
-    function Convert<T extends Types.TSchema>(schema: T, value: unknown): value is Types.Static<T>;
+    function Convert<T extends Types.TSchema>(schema: T, value: unknown): unknown;
     /** Returns a structural clone of the given value */
     function Clone<T>(value: T): T;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): IterableIterator<ValueError>;
+    function Errors<T extends Types.TSchema, R extends Types.TSchema[]>(schema: T, references: [...R], value: unknown): ValueErrorIterator;
     /** Returns an iterator for each error in this value. */
-    function Errors<T extends Types.TSchema>(schema: T, value: unknown): IterableIterator<ValueError>;
+    function Errors<T extends Types.TSchema>(schema: T, value: unknown): ValueErrorIterator;
     /** Returns true if left and right values are structurally equal */
     function Equal<T>(left: T, right: unknown): right is T;
     /** Returns edits to transform the current value into the next value */

package/value/value.js

@@ -65,9 +65,9 @@ var Value;
         return clone_1.ValueClone.Clone(value);
     }
     Value.Clone = Clone;
-    function* Errors(...args) {
+    function Errors(...args) {
         const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-        yield* index_1.ValueErrors.Errors(schema, references, value);
+        return index_1.ValueErrors.Errors(schema, references, value);
     }
     Value.Errors = Errors;
     /** Returns true if left and right values are structurally equal */