typebox 1.0.55 → 1.0.57

package/build/compile/compile.d.mts

@@ -1,6 +1,6 @@
 import { type TProperties, type TSchema } from '../type/index.mjs';
 import { Validator } from './validator.mjs';
 /** Compiles a type into a high performance Validator */
-export declare function Compile<const Type extends TSchema>(type: Type): Validator<{}, Type>;
+export declare function Compile<const Type extends TSchema, Result extends Validator = Validator<{}, Type>>(type: Type): Result;
 /** Compiles a type into a high performance Validator */
-export declare function Compile<Context extends TProperties, const Type extends TSchema>(context: Context, type: Type): Validator<Context, Type>;
+export declare function Compile<Context extends TProperties, const Type extends TSchema, Result extends Validator = Validator<Context, Type>>(context: Context, type: Type): Result;

package/build/compile/validator.d.mts

@@ -1,6 +1,6 @@
 import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type StaticDecode, type StaticEncode, type TProperties, type TSchema, Base } from '../type/index.mjs';
-export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema> extends Base<StaticEncode<Type, Context>> {
+export declare class Validator<Context extends TProperties = TProperties, Type extends TSchema = TSchema, Encode extends unknown = StaticEncode<Type, Context>, Decode extends unknown = StaticDecode<Type, Context>> extends Base<Encode> {
     private readonly context;
     private readonly type;
     private readonly isEvaluated;
@@ -20,7 +20,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     /** Returns the generated code for this validator. */
     Code(): string;
     /** Checks a value matches the Validator type. */
-    Check(value: unknown): value is StaticEncode<Type, Context>;
+    Check(value: unknown): value is Encode;
     /** Returns errors for the given value. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
@@ -28,15 +28,15 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     /** Converts a value using the Validator type. */
     Convert(value: unknown): unknown;
     /** Creates a value using the Validator type. */
-    Create(): StaticEncode<Type, Context>;
+    Create(): Encode;
     /** Creates defaults using the Validator type. */
     Default(value: unknown): unknown;
     /** Clones this validator. */
     Clone(): Validator<Context, Type>;
     /** Parses a value */
-    Parse(value: unknown): StaticDecode<Type, Context>;
+    Parse(value: unknown): Decode;
     /** Decodes a value */
-    Decode(value: unknown): StaticDecode<Type, Context>;
+    Decode(value: unknown): Decode;
     /** Encodes a value */
-    Encode(value: unknown): StaticEncode<Type, Context>;
+    Encode(value: unknown): Encode;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "keywords": [
     "typescript",
     "jsonschema"

package/readme.md

@@ -61,6 +61,8 @@ License: MIT
 - [Type](#Type)
 - [Value](#Value)
 - [Compile](#Compile)
+- [Schema](#Schema)
+- [Script](#Script)
 - [Contribute](#Contribute)
 
 ## Upgrade
@@ -101,30 +103,29 @@ type T = Type.Static<typeof T>                      // type T = {
                                                     // }
 ```
 
-Options and constraints can be passed on the last argument of any given type.
+Schema options can be passed on the last argument of any given type.
 
 ```typescript
-const T = Type.Number({                            // const T = {
+const T = Type.String({                            // const T = {
+  format: 'email'                                  //   type: 'string',
+})                                                 //   format: 'email'
+                                                   // }
+
+const S = Type.Number({                            // const S = {
   minimum: 0,                                      //   type: 'number',
   maximum: 100                                     //   minimum: 0,
 })                                                 //   maximum: 100
                                                    // }
 
-const S = Type.String({                            // const S = {
-  format: 'email'                                  //   type: 'string',
-})                                                 //   format: 'email'
-                                                   // }
 ```
 
 <a name="Value"></a>
 
 ## Value
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoUSWOANQEMAbAV3Sx30LVLIHoAbi3ZVKAYwgA7AM7wEcALyIiAOgDyxAFapxMABQBvSnDhkAXCrSqAcqxDFUUfQEoANCbhJLya3YdOrh6mAF4+av6Ozi6UAL4xlPz8cADCABa6ANaUEtJycACCSgwiqKrpWfoIbnCGpvUNjU1NSXCSsvAFlqQQzKiMUsUwUOyeFnAAjDXNM7Nzs57ecABMwXBhcADMcQmtAAqMUDKoOe35AELFTGxlB0eoVTV18y+mrWfw55bGpuNTrwDAfVWr9LFJ7FE1ktVkDYS8QV4wRCnGsNps4RjZgiNuCAlAdpjCVjkrFiqpyUA)
-
-The TypeBox Value module provides functions to Check and Parse JavaScript values. It also includes functions such as Clone, Repair, Encode, Decode, Diff and Patch which perform various structural operations on JavaScript values.
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/value/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBANQIYBsCuBTOAzKERwDkMAnmBgEYQAeA9AG6qaEBQokscAKmVrvkVLkq1ViwDGEAHYBneFzgBebrwB0AeQoArDOJgAKAN4s4cagC4V5VQDk0IChij6AlABoTcEpZ7W7Dp1cPUwAvHzV-R2cXFgBfGIlpOTgAQSVEJgxVAAUkKBkMfS43OENTcorKqqraWjhJWXgUy2NTCzgARhLqnt6+vtry9ql7KOCvSwAGbv7ZuerB0284EYCocbC4Sfmd3bhFuE3VqLiXPfOdwdj01VugA)
 
-The Value module is available via optional import.
+The Value module provides functions that perform typed operations on JavaScript values. It includes functions such as Check, Parse, Clone, Encode, Decode and as well as advanced functions to perform structural Diff and Patch on dynamic JavaScript values.
 
 ```typescript
 import Value from 'typebox/value'
@@ -132,7 +133,7 @@ import Value from 'typebox/value'
 
 ### Example
 
-The following uses the Value module to Check and Parse a value. 
+The following uses the Value module to Parse a value. 
 
 ```typescript
 const T = Type.Object({
@@ -141,20 +142,10 @@ const T = Type.Object({
   z: Type.Number()
 })
 
-// Check
-
-const A = Value.Check(T, {                          // const A: boolean = true
-  x: 1,                                            
-  y: 2,
-  z: 3
-})
-
-// Parse
-
-const B = Value.Parse(T, {                          // const B: {
+const A = Value.Parse(T, {                          // const A: {
   x: 1,                                             //   x: number,
-  y: 2,                                             //   y: number,
-  z: 3                                              //   z: number
+  y: 0,                                             //   y: number,
+  z: 0                                              //   z: number
 })                                                  // } = ...
 ```
 
@@ -163,11 +154,9 @@ const B = Value.Parse(T, {                          // const B: {
 
 ## Compile
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1IChRJY4AKlRxES5YXXrcurAHYBneMjgBeFGw4AKIdQB0AeRoArLMxiakcK9Zu3bjRnDmKUALjgA1AIYZgAEy8YaAAeBFwAGkFDEzNQrit6dx0sXQA5AFcQGiwoTQBKSLsi4pKrB2tEwQysnPD4uAok4TTM7NyC0s6u8qtGqtba+oAvJr1qtvyuqZKeuBH+mqguXDy86fWNm3LcAD4dri5y5AALUwBrA+d4AEFVFF0T84tNjfKruGv3OghsL1k7mBQdJYeqVACMhReUNs9T6ACY6lZ5gBmZZ5A7lAAKXig8hBMggCngACE7shdNjcVhntDuo53sT3AhQe4IbT2WVHAl3LIBlBEQ13AiOezZn1eYsBSiRaKuXMeXy0TKZds7rp1UA)
-
-The TypeBox Compile module provides functions to convert types into high-performance validators. The compiler is tuned for fast compilation as well as fast validation.
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1IChRJY4AKlRxES5YXXrcurAHYBneMjgBeFGw4AKIdQB0AeRoArLMxiakcK9Zu3bjRnDmKUALjgA1AIYZgAEy8YaAAeBFwAGkFDEzNQrit6dx0sXQA5AFcQGiwoTQBKSLsi4pKrB2tEwQysnPD4uAok4TTM7NyC0s6u8qtGqtba+oAvJr1qtvyuqZKeuBH+mqguXDy86fWNm3LcAD4drhkIBXgAQVUUXQAFLyh5LAtNjfLnU-cEesqABkLH37tZyqyAZQOq9dwARh+f2hcFmfSBi1Bc3cnxhaNhjis8wRbWWa3RBO2510JKAA)
 
-The Compile module is available via optional import.
+The Compile module is a high-performance JIT compiler that transforms types into efficient runtime validators. The compiler is optimized for both fast compilation and validation.
 
 ```typescript
 import { Compile } from 'typebox/compile' 
@@ -175,7 +164,7 @@ import { Compile } from 'typebox/compile'
 
 ### Example
 
-The following uses the Compile module to Check and Parse a value. 
+The following uses the compiler to Compile and Parse a value. 
 
 ```typescript
 const C = Compile(Type.Object({                     // const C: Validator<{}, TObject<{
@@ -184,23 +173,100 @@ const C = Compile(Type.Object({                     // const C: Validator<{}, TO
   z: Type.Number()                                  //   z: TNumber
 }))                                                 // }>>
 
-// Check
+const A = C.Parse({                                 // const A: {
+  x: 0,                                             //   x: number,
+  y: 1,                                             //   y: number,
+  z: 0                                              //   z: number
+})                                                  // } = ...
+```
 
-const A = C.Check({                                 // const A: boolean = true
-  x: 1,                                            
-  y: 2,
-  z: 3
-})
+<a name="Schema"></a>
 
-// Parse
+## Schema
 
-const B = C.Parse({                                 // const B: {
-  x: 1,                                             //   x: number,
-  y: 2,                                             //   y: number,
-  z: 3                                              //   z: number
+[Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAbzgYQuYAbApnAvnAMyjTgHIYBPMLAIwgA8B6AYzTEy1ICgfWA7AM7xkcALwo2HABQIucOJWoAuMhBoArLMxikANHLhQsARwCuwIwBMVAbVL09ZCo9IAvUgF198sMWqxgLAEVWXl5ehCFKiwVUj5TEBosKFI8bzCKSMUYsnjE5NTcdPlXLOjYvKSUvANcLlwASl4IQXgAQTEUADoABQBDKAEsGTDRsfGJycZGOH4hODaQgwi4AAZdSc2t7YnpsJXK5PTMtY2d84uxvfkTw6h00rgARkvXy+u4R7v6hre-95m+HEXRBQA) | [Example 2](https://tsplay.dev/mxrl7w)
+
+TypeBox is built upon a high-performance validation infrastructure that supports the direct compilation and inference of Json Schema schematics. TypeBox implements Draft 3 to 2020-12 and is compliance tested via the official Json Schema [Test Suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite). It offers high-performance JIT compilation with automatic fallback to dynamic checking in JIT restricted environments.
+
+### Example
+
+The following compiles Json Schema. Type inference is supported.
+
+```typescript
+const C = Compile({
+  type: 'object',
+  required: ['x', 'y', 'z'],
+  properties: {
+    x: { type: 'number' },
+    y: { type: 'number' },
+    z: { type: 'number' }
+  }
+})
+
+const A = C.Parse({                                 // const A: {
+  x: 0,                                             //   x: number,
+  y: 0,                                             //   y: number,
+  z: 1                                              //   z: number
 })                                                  // } = ...
 ```
 
+It can also be used to accelerate remote libraries via Json Schema translation.
+
+```typescript
+const C = Compile(x.toJsonSchema(x.object({
+  x: x.number(),
+  y: x.number(),
+  z: x.number()
+})))
+
+const A = C.Check(...)                              // high performance runtime checking
+```
+
+## Script
+
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgGUBjKYMGVAE0SOqYgB2AZ3gI4AXh5oAdM1bsAFAAMA3nEpw4ZAFxwBAVxDFUUADTrNSXSNYCA5uY1wAXrtIQANqgCGA9QF8lAEpNULDwiMio6PC6OH5hUV0EAHliACtUJhgAHhUnGMKi4rC4zR1EADlDYzMCkobG0vpLZIYYWwd6pp7ispdkgCEITx8Bbt7JqLj-AD5qOIApIUFGJgALVBBvOABJAQ6IITRs4EFqBGlCNCnb0Li8CAysmCpLqFQAR31gD+47npxADaeAo5jwSDw4OceAAupRLmBsGhYMBUEIAY04moKtI8eYrHA8dJzK4iXi4P4FvQ5GwONxkDcFABhHBgfT0oJ8QQiRgSKSoWQsOkKNRifzmVROIEAaTgwD8AGtUEgIBhELDkrLYXAAD56fQeDyUQIhTF3OIJXkMZJpTLZPITc2TfoVBAAVQEZwEOSBCGqRhM5n9ho8sNmpidzsBLTghI9XsEvoQ7U6weqRvDkejAP6ZIT3uTw1GvnTofDUZzDRm81oNJgvk43ig3H2GBMqAETFQ1Gu6AY-MZgva3hgwCYOT7asYs1ucT7fMk+Src9jFQMgageoNRuzK5dscJNgVdm3Bl3lf3hTzbhGXl8Z9Dl6v0RmQA) | [Example 2](https://www.typescriptlang.org/play/?#code/JYWwDg9gTgLgBAFQJ5gKZwGZQiOByGFVAIwgA88AoSgehrgAkIA3VKOGAC1QGd0NocYADsMbVMIDG6ABQ9OEAK4AbACZwQAQxiTOHbnB6SowMDFTrCaAJSVUZSLA5E4AMQgQ4AXkREAdADKMNrAkgA8VqgQGG4eAHx2DtDwkXAAQprsPshogcEwoRFE0emZCbT0AMIQYEhwmsLqYJo85ogBzmg8QsIwnjmogcamMDJ+49b1jXAA5qjwxJqSANadqAC0PJpicABSAQDyAHJwAbqoWomO8JIQwq1wAN6xEAA0pewAvt6+uWcmZhkAANKKl3J4fI9KHA4GQAFxwYSKEDENjQuBIBFIlFomEALyxyNRUEon2oqQyWSe6KgqE0qjuyjqAG0ANI9ODLVBIErg+rdACymjAYVZcQAugiAIKqZgNaSqUVxOAAHxebPFpPJLhlcqkFlF3PeADVMsAGjBuj48AANPCq-AATXtarwAC08MqfDJ0QAdIG+gAkjwAqmA0FBJC1UIakHFPkHHqaTBaeJ91qBIDweMBiMpUP7KLZQS4hSLWdyvXAwxGo3wwuiK3V7OZGt08BQ4AB+fCae1wxvcuAtiSqdtIe09vDEfuD5tkVtj-B4yf4SSzmHCVCsEnlIG2OhwA6KGBgE9rbqZfgqJlwWkYfOSYJ59D7Y6nc6XcF+VIwv---9DzwCBiAAK1QJ97TgShvzAbAIwKXgAL-Q9nnhOBxj8d5MQw8Z3gJXC-DgMlv1pABHRRgFpdRkJQ+hmQ7PB3jwCdmJXcUgA)
+
+TypeBox includes a TypeScript scripting engine able to parse TypeScript types directly into Json Schema. The engine uses symmetric runtime and type-level parsing and returns typed safe schematics from TypeScript types (including computed types). The engine is designed for TypeScript 7 native compiler but is supported in TypeScript 5 and above.
+
+```typescript
+// Scripted Type
+
+const T = Type.Script(`{ 
+  x: number, 
+  y: string, 
+  z: boolean 
+}`)                                                 // const T: TObject<{
+                                                    //   x: TNumber,
+                                                    //   y: TString,
+                                                    //   z: TBoolean
+                                                    // }>
+
+// Json Schema Introspection
+
+T.type                                              // 'object'
+T.required                                          // ['x', 'y', 'z']
+T.properties                                        // { x: ..., y: ..., z: ... }
+
+// Scripted Type (Computed)
+
+const S = Type.Script({ T }, `{
+  [K in keyof T]: T[K] | null
+}`)                                                 // const S: TObject<{
+                                                    //   x: TUnion<[TNumber, TNull]>,
+                                                    //   y: TUnion<[TString, TNull]>,
+                                                    //   z: TUnion<[TBoolean, TNull]>
+                                                    // }>
+
+// Standard Inference
+
+type S = Type.Static<typeof S>                      // type S = {
+                                                    //   x: number | null,
+                                                    //   y: string | null,
+                                                    //   z: boolean | null
+                                                    // }
+```
+
+
 ## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an issue before submitting a pull request. The TypeBox project prefers open community discussion before accepting new features.