@sinclair/typebox 0.32.0-dev-28 → 0.32.0

package/build/import/type/indexed/indexed-property-keys.d.mts

@@ -5,7 +5,7 @@ import type { TNumber } from '../number/index.mjs';
 import type { TSchema } from '../schema/index.mjs';
 import type { TUnion } from '../union/index.mjs';
 type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
-type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...TIndexPropertyKeys<L>, ...Acc]> : Acc);
+type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]> : Acc);
 type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TLiteral<infer S> ? TFromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);

package/build/require/type/indexed/indexed-property-keys.d.ts

@@ -5,7 +5,7 @@ import type { TNumber } from '../number/index';
 import type { TSchema } from '../schema/index';
 import type { TUnion } from '../union/index';
 type TFromTemplateLiteral<T extends TTemplateLiteral, R extends string[] = TTemplateLiteralGenerate<T>> = (R);
-type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...TIndexPropertyKeys<L>, ...Acc]> : Acc);
+type TFromUnion<T extends TSchema[], Acc extends string[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, [...Acc, ...TIndexPropertyKeys<L>]> : Acc);
 type TFromLiteral<T extends TLiteralValue> = (T extends PropertyKey ? [`${T}`] : []);
 export type TIndexPropertyKeys<T extends TSchema> = (T extends TTemplateLiteral ? TFromTemplateLiteral<T> : T extends TUnion<infer S> ? TFromUnion<S> : T extends TLiteral<infer S> ? TFromLiteral<S> : T extends TNumber ? ['[number]'] : T extends TInteger ? ['[number]'] : [
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.32.0-dev-28",
+  "version": "0.32.0",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -648,12 +648,14 @@ TypeBox provides an extended type set that can be used to create schematics for
 
 ### Import
 
-You can import Type to bring in the full type system. This is recommended for most users.
+Import the Type namespace to bring in TypeBox's full type system. This is recommended for most users.
 
 ```typescript
 import { Type, type Static } from '@sinclair/typebox'
 ```
-You can also import types individually. This approach enables modern bundlers to tree shake unused types.
+
+You can also selectively import types. This enables modern bundlers to tree shake for unused types.
+
 ```typescript
 import { Object, Number, String, Boolean, type Static } from '@sinclair/typebox'
 ```
@@ -906,11 +908,11 @@ const R = Type.Record(K, Type.String())              // const R: TObject<{
 TypeBox supports indexed access types with Index. This type enables uniform access to interior property and element types without having to extract them from the underlying schema representation. This type is supported for Object, Array, Tuple, Union and Intersect types.
 
 ```typescript
-const T = Type.Object({                              // const T: TObject<{
-  x: Type.Number(),                                  //   x: TNumber,
-  y: Type.String(),                                  //   y: TString,
-  z: Type.Boolean()                                  //   z: TBoolean
-})                                                   // }>
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
 
 const A = Type.Index(T, ['x'])                       // type A = T['x']
                                                      //
@@ -945,17 +947,17 @@ const C = Type.Index(T, Type.KeyOf(T))               // type C = T[keyof T]
 TypeBox supports mapped object types with Mapped. This type accepts two arguments, the first is a union type typically derived from KeyOf, the second is a mapping function that receives a mapping key `K` that can be used to index properties of a type. The following implements Partial using mapped types.
 
 ```typescript
-const T = Type.Object({                              // const T: TObject<{
-  x: Type.Number(),                                  //   x: TNumber,
-  y: Type.String(),                                  //   y: TString,
-  z: Type.Boolean()                                  //   z: TBoolean
-})                                                   // }>
+const T = Type.Object({                              // type T = {
+  x: Type.Number(),                                  //   x: number,
+  y: Type.String(),                                  //   y: string,
+  z: Type.Boolean()                                  //   z: boolean
+})                                                   // }
 
-const P = Type.Mapped(Type.KeyOf(T), K => {          // type P = { [K in keyof T]?: T[K] }
+const M = Type.Mapped(Type.KeyOf(T), K => {          // type M = { [K in keyof T]?: T[K] }
   return Type.Optional(Type.Index(T, K))             //
 })                                                   // ... evaluated as
                                                      // 
-                                                     // const P: TObject<{
+                                                     // const M: TObject<{
                                                      //   x: TOptional<TNumber>,
                                                      //   y: TOptional<TString>,
                                                      //   z: TOptional<TBoolean>
@@ -970,29 +972,29 @@ TypeBox supports runtime conditional types with Extends. This type performs a st
 
 ```typescript
 // Extends
-const T = Type.Extends(                              // type T = string extends number ? true : false
+const A = Type.Extends(                              // type A = string extends number ? 1 : 2
   Type.String(),                                     //   
   Type.Number(),                                     // ... evaluated as
-  Type.Literal(true),                                //
-  Type.Literal(false)                                // const T: TLiteral<false>
+  Type.Literal(1),                                   //
+  Type.Literal(2)                                    // const A: TLiteral<2>
 )
 
 // Extract
-const T = Type.Extract(                              // type T = Extract<1 | 2 | 3, 1>
+const B = Type.Extract(                              // type B = Extract<1 | 2 | 3, 1>
   Type.Union([                                       //
     Type.Literal(1),                                 // ... evaluated as
     Type.Literal(2),                                 //
-    Type.Literal(3)                                  // const T: TLiteral<1>
+    Type.Literal(3)                                  // const B: TLiteral<1>
   ]), 
   Type.Literal(1)
 )
 
 // Exclude
-const T = Type.Exclude(                              // type T = Exclude<1 | 2 | 3, 1>
+const C = Type.Exclude(                              // type C = Exclude<1 | 2 | 3, 1>
   Type.Union([                                       // 
     Type.Literal(1),                                 // ... evaluated as
     Type.Literal(2),                                 //
-    Type.Literal(3)                                  // const T: TUnion<[
+    Type.Literal(3)                                  // const C: TUnion<[
   ]),                                                //   TLiteral<2>,
   Type.Literal(1)                                    //   TLiteral<3>,
 )                                                    // ]>
@@ -1040,11 +1042,11 @@ TypeBox supports value decoding and encoding with Transform types. These types w
 import { Value } from '@sinclair/typebox/value'
 
 const T = Type.Transform(Type.Number())
-  .Decode(value => new Date(value))                  // required: number to Date
-  .Encode(value => value.getTime())                  // required: Date to number
+  .Decode(value => new Date(value))                  // decode: number to Date
+  .Encode(value => value.getTime())                  // encode: Date to number
 
-const decoded = Value.Decode(T, 0)                   // const decoded = Date(1970-01-01T00:00:00.000Z)
-const encoded = Value.Encode(T, decoded)             // const encoded = 0
+const D = Value.Decode(T, 0)                         // const D = Date(1970-01-01T00:00:00.000Z)
+const E = Value.Encode(T, D)                         // const E = 0
 ```
 Use the StaticEncode or StaticDecode types to infer a Transform type.
 ```typescript
@@ -1419,15 +1421,18 @@ The TypeBox type system can be extended with additional types and formats using
 
 ### TypeRegistry
 
-Use the TypeRegistry to register a new type. The Kind must match the registered type name.
+Use the TypeRegistry to register a type. The Kind must match the registered type name.
 
 ```typescript
-import { TypeRegistry, Symbols } from '@sinclair/typebox'
+import { TSchema, Kind, TypeRegistry } from '@sinclair/typebox'
 
 TypeRegistry.Set('Foo', (schema, value) => value === 'foo')
 
-const A = Value.Check({ [Kind]: 'Foo' }, 'foo')      // const A = true
-const B = Value.Check({ [Kind]: 'Foo' }, 'bar')      // const B = false
+const Foo = { [Kind]: 'Foo' } as TSchema 
+
+const A = Value.Check(Foo, 'foo')                    // const A = true
+
+const B = Value.Check(Foo, 'bar')                    // const B = false
 ```
 
 <a name='typeregistry-format'></a>
@@ -1444,6 +1449,7 @@ FormatRegistry.Set('foo', (value) => value === 'foo')
 const T = Type.String({ format: 'foo' })
 
 const A = Value.Check(T, 'foo')                      // const A = true
+
 const B = Value.Check(T, 'bar')                      // const B = false
 ```