@sinclair/typebox 0.29.3 → 0.29.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.29.3",
+  "version": "0.29.4",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -24,10 +24,13 @@
     "url": "https://github.com/sinclairzx81/typebox"
   },
   "scripts": {
+    "test:typescript": "hammer task test_typescript",
+    "test:static": "hammer task test_static",
+    "test:runtime": "hammer task test_runtime",
+    "test": "hammer task test",
     "clean": "hammer task clean",
     "format": "hammer task format",
     "start": "hammer task start",
-    "test": "hammer task test",
     "benchmark": "hammer task benchmark",
     "build": "hammer task build",
     "publish": "hammer task publish"

package/readme.md

@@ -11,8 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
-[![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Build](https://github.com/sinclairzx81/typebox/actions/workflows/build.yml/badge.svg)](https://github.com/sinclairzx81/typebox/actions/workflows/build.yml)
+[![License](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 </div>
 
@@ -335,15 +335,15 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Composite([     │ type I = {                  │ const T = {                    │
+│ const T = Type.Composite([     │ type T = {                  │ const T = {                    │
 │   Type.Object({                │   x: number                 │   type: 'object',              │
 │     x: Type.Number()           │ } & {                       │   required: ['x', 'y'],        │
 │   }),                          │   y: number                 │   properties: {                │
 │   Type.Object({                │ }                           │     x: {                       │
 │     y: Type.Number()           │                             │       type: 'number'           │
-│   })                           │ type T = {                  │     },                         │
-│ ])                             │   [K in keyof I]: I[K]      │     y: {                       │
-│                                │ }                           │       type: 'number'           │
+│   })                           │                             │     },                         │
+│ ])                             │                             │     y: {                       │
+│                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
 │                                │                             │ }                              │
@@ -739,12 +739,12 @@ const R = Type.Ref(T)                                // const R = {
 
 ### Recursive Types
 
-Recursive types are supported with `Type.Recursive`
+Recursive types are supported with `Type.Recursive`.
 
 ```typescript
-const Node = Type.Recursive(Node => Type.Object({    // const Node = {
+const Node = Type.Recursive(This => Type.Object({    // const Node = {
   id: Type.String(),                                 //   $id: 'Node',
-  nodes: Type.Array(Node)                            //   type: 'object',
+  nodes: Type.Array(This)                            //   type: 'object',
 }), { $id: 'Node' })                                 //   properties: {
                                                      //     id: {
                                                      //       type: 'string'
@@ -776,38 +776,50 @@ function test(node: Node) {
 
 ### Conditional Types
 
-Conditional types are supported with `Type.Extends`, `Type.Exclude` and `Type.Extract`
+TypeBox supports conditional types with `Type.Extends`. This type will perform a structural assignment check for the first two parameters and return a `true` or `false` type from the second two parameters. The types `Type.Exclude` and `Type.Extract` are also supported.
 
 ```typescript
 // TypeScript
 
 type T0 = string extends number ? true : false       // type T0 = false
 
-type T1 = Extract<string | number, number>           // type T1 = number
+type T1 = Extract<(1 | 2 | 3), 1>                    // type T1 = 1
 
-type T2 = Exclude<string | number, number>           // type T2 = string
+type T2 = Exclude<(1 | 2 | 3), 1>                    // type T2 = 2 | 3
 
 // TypeBox
 
-const T0 = Type.Extends(Type.String(), Type.Number(), Type.Literal(true), Type.Literal(false))
-
-const T1 = Type.Extract(Type.Union([Type.String(), Type.Number()]), Type.Number())
-
-const T2 = Type.Exclude(Type.Union([Type.String(), Type.Number()]), Type.Number())
-
-
-type T0 = Static<typeof T0>                        // type T0 = false
+const T0 = Type.Extends(                             // const T0: TLiteral<false>
+  Type.String(), 
+  Type.Number(), 
+  Type.Literal(true), 
+  Type.Literal(false)
+)
 
-type T1 = Static<typeof T1>                        // type T1 = number
+const T1 = Type.Extract(                             // const T1: TLiteral<1>
+  Type.Union([
+    Type.Literal(1), 
+    Type.Literal(2), 
+    Type.Literal(3) 
+  ]), 
+  Type.Literal(1)
+)
 
-type T2 = Static<typeof T2>                        // type T2 = string
+const T2 = Type.Exclude(                            // const T2: TUnion<[
+  Type.Union([                                      //   TLiteral<2>,
+    Type.Literal(1),                                //   TLiteral<3>
+    Type.Literal(2),                                // ]>
+    Type.Literal(3) 
+  ]), 
+  Type.Literal(1)
+)
 ```
 
 <a name='types-template-literal'></a>
 
 ### Template Literal Types
 
-TypeBox supports Template Literal types using `Type.TemplateLiteral`. These types can be created using a simple template DSL syntax, however more complex template literals can be created by passing an array of literal and union types. The examples below show the template DSL syntax.
+TypeBox supports template literal types with `Type.TemplateLiteral`. This type implements an embedded DSL syntax to match the TypeScript template literal syntax. This type can also be composed by passing an array of union and literal types as parameters. The following example shows the DSL syntax.
 
 ```typescript
 // TypeScript
@@ -853,7 +865,7 @@ const R = Type.Record(T, Type.String())              // const R = {
 
 ### Indexed Access Types
 
-TypeBox supports Indexed Access types using `Type.Index`. This feature provides a consistent way to access property types without having to extract them from the underlying schema representation. Indexed accessors are supported for object and tuples, as well as nested union and intersect types.
+TypeBox supports indexed access types using `Type.Index`. This type provides a consistent way to access interior property and array element types without having to extract them from the underlying schema representation. Indexed access types are supported for object, array, tuple, union and intersect types.
 
 ```typescript
 const T = Type.Object({                              // const T = {
@@ -888,7 +900,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Not Types
 
-TypeBox has partial support for the JSON schema `not` keyword with `Type.Not`. This type is synonymous with the concept of a [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. TypeBox does provide partial inference support via the intersection of `T & not U` (where all negated types infer as `unknown`). This can be used in the following context.
+TypeBox provides support for the `not` keyword with `Type.Not`. This type is synonymous with [negated types](https://github.com/microsoft/TypeScript/issues/4196) which are not supported in the TypeScript language. Partial inference of this type can be attained via the intersection of `T & not U` (where all Not types infer as `unknown`). This approach can be used to narrow for broader types in the following context.
 
 ```typescript
 // TypeScript

package/typebox.d.ts

@@ -103,11 +103,12 @@ 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 TCompositeReduce<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] ? {
+export type TCompositeKeys<T extends TObject[]> = T extends [infer L, ...infer R] ? keyof Assert<L, TObject>['properties'] | TCompositeKeys<Assert<R, TObject[]>> : never;
+export type TCompositeIndex<T extends TIntersect<TObject[]>, K extends string[]> = K extends [infer L, ...infer R] ? {
     [_ in Assert<L, string>]: TIndexType<T, Assert<L, string>>;
-} & TCompositeReduce<T, Assert<R, string[]>> : {};
-export type TCompositeSelect<T extends TIntersect<TObject[]>> = UnionToTuple<keyof Static<T>> extends infer K ? Evaluate<TCompositeReduce<T, Assert<K, string[]>>> : {};
-export type TComposite<T extends TObject[]> = TIntersect<T> extends infer R ? TObject<TCompositeSelect<Assert<R, TIntersect<TObject[]>>>> : TObject<{}>;
+} & TCompositeIndex<T, Assert<R, string[]>> : {};
+export type TCompositeReduce<T extends TObject[]> = UnionToTuple<TCompositeKeys<T>> extends infer K ? Evaluate<TCompositeIndex<TIntersect<T>, Assert<K, string[]>>> : {};
+export type TComposite<T extends TObject[]> = TIntersect<T> extends TIntersect ? TObject<TCompositeReduce<T>> : TObject<{}>;
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
     [K in keyof T]: Static<AssertType<T[K]>, P>;
 }];
@@ -335,13 +336,14 @@ export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperti
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
 }>>;
 export type TRequired<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TRequired<S>> : T extends TIntersect<infer S> ? TIntersect<TRequiredArray<S>> : T extends TUnion<infer S> ? TUnion<TRequiredArray<S>> : T extends TObject<infer S> ? TObject<TRequiredProperties<S>> : T;
-export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 export interface StringOptions extends SchemaOptions {
     minLength?: number;
     maxLength?: number;
     pattern?: string;
-    format?: string;
-    contentEncoding?: '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64';
+    format?: StringFormatOption;
+    contentEncoding?: StringContentEncodingOption;
     contentMediaType?: string;
 }
 export interface TString extends TSchema, StringOptions {