typebox 1.1.0 → 1.1.2

package/build/schema/check.d.mts

@@ -1,5 +1,6 @@
 import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
 /** Checks a value against the provided schema */
-export declare function Check(schema: Schema.XSchema, value: unknown): boolean;
+export declare function Check<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): value is Static.XStatic<Schema>;
 /** Checks a value against the provided schema */
-export declare function Check(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, value: unknown): boolean;
+export declare function Check<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): value is Static.XStatic<Schema>;

package/build/schema/compile.d.mts

@@ -0,0 +1,18 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
+export declare class Validator<Schema extends Schema.XSchema, Value extends unknown = Static.XStatic<Schema>> {
+    private readonly build;
+    private readonly result;
+    constructor(context: Record<string, Schema.XSchema>, schema: Schema);
+    /** Checks this value is valid */
+    Check(value: unknown): value is Value;
+    /** Parses this value and throw if invalid */
+    Parse(value: unknown): Value;
+    /** Returns errors for the given value */
+    Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
+}
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(schema: Schema): Validator<Schema>;
+/** Compiles this schema into a high performance Validator */
+export declare function Compile<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema): Validator<Schema>;

package/build/schema/compile.mjs

@@ -0,0 +1,38 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import * as Build from './build.mjs';
+import { Errors } from './errors.mjs';
+import { ParseError } from './parse.mjs';
+// ------------------------------------------------------------------
+// Validator
+// ------------------------------------------------------------------
+export class Validator {
+    constructor(context, schema) {
+        this.build = Build.Build(context, schema);
+        this.result = this.build.Evaluate();
+    }
+    /** Checks this value is valid */
+    Check(value) {
+        return this.result.Check(value);
+    }
+    /** Parses this value and throw if invalid */
+    Parse(value) {
+        if (this.result.Check(value))
+            return value;
+        const [_result, errors] = Errors(this.build.Context(), this.build.Schema(), value);
+        throw new ParseError(this.build.Schema(), value, errors);
+    }
+    /** Returns errors for the given value */
+    Errors(value) {
+        return Errors(this.build.Context(), this.build.Schema(), value);
+    }
+}
+/** Compiles this schema into a high performance Validator */
+export function Compile(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    return new Validator(context, schema);
+}

package/build/schema/parse.d.mts

@@ -0,0 +1,13 @@
+import { type TLocalizedValidationError } from '../error/index.mjs';
+import * as Schema from './types/index.mjs';
+import * as Static from './static/index.mjs';
+export declare class ParseError {
+    schema: Schema.XSchema;
+    value: unknown;
+    errors: TLocalizedValidationError[];
+    constructor(schema: Schema.XSchema, value: unknown, errors: TLocalizedValidationError[]);
+}
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(schema: Schema, value: unknown): Static.XStatic<Schema>;
+/** Parses a value against the provided schema */
+export declare function Parse<const Schema extends Schema.XSchema>(context: Record<PropertyKey, Schema.XSchema>, schema: Schema, value: unknown): Static.XStatic<Schema>;

package/build/schema/parse.mjs

@@ -0,0 +1,27 @@
+// deno-fmt-ignore-file
+// deno-lint-ignore-file
+import { Arguments } from '../system/arguments/index.mjs';
+import { Check } from './check.mjs';
+import { Errors } from './errors.mjs';
+// ------------------------------------------------------------------
+// ParseError
+// ------------------------------------------------------------------
+export class ParseError {
+    constructor(schema, value, errors) {
+        this.schema = schema;
+        this.value = value;
+        this.errors = errors;
+    }
+}
+/** Parses a value against the provided schema */
+export function Parse(...args) {
+    const [context, schema, value] = Arguments.Match(args, {
+        3: (context, schema, value) => [context, schema, value],
+        2: (schema, value) => [{}, schema, value]
+    });
+    if (!Check(context, schema, value)) {
+        const [_result, errors] = Errors(context, schema, value);
+        throw new ParseError(schema, value, errors);
+    }
+    return value;
+}

package/build/schema/schema.d.mts

@@ -4,5 +4,7 @@ export * from './resolve/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';
+export * from './compile.mjs';
 export * from './check.mjs';
+export * from './parse.mjs';
 export * from './errors.mjs';

package/build/schema/schema.mjs

@@ -4,5 +4,7 @@ export * from './resolve/index.mjs';
 export * from './static/index.mjs';
 export * from './types/index.mjs';
 export * from './build.mjs';
+export * from './compile.mjs';
 export * from './check.mjs';
+export * from './parse.mjs';
 export * from './errors.mjs';

package/build/schema/types/index.d.mts

@@ -47,7 +47,6 @@ export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';
-export * from './schema.mjs';
 export * from './then.mjs';
 export * from './type.mjs';
 export * from './uniqueItems.mjs';

package/build/schema/types/index.mjs

@@ -53,7 +53,6 @@ export * from './recursiveRef.mjs';
 export * from './ref.mjs';
 export * from './required.mjs';
 export * from './schema.mjs';
-export * from './schema.mjs';
 export * from './then.mjs';
 export * from './type.mjs';
 export * from './uniqueItems.mjs';

package/package.json

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

package/readme.md

@@ -25,13 +25,9 @@ $ npm install typebox
 
 ## Usage
 
-A TypeScript engine for JSON Schema [Example](https://tsplay.dev/mZMOeN)
-
 ```typescript
 import Type from 'typebox'
 
-// JSON Schema
-
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
   y: Type.Number(),                                 //   required: ['x', 'y', 'z'],
@@ -47,20 +43,6 @@ type T = Type.Static<typeof T>                      // type T = {
                                                     //   y: number,
                                                     //   z: number
                                                     // }
-
-// TypeScript
-
-const { S } = Type.Script({ T }, `
-  type S = {
-    readonly [K in keyof T as Uppercase<K>]: string
-  }
-`)
-
-type S = Type.Static<typeof S>                      // type S = {
-                                                    //   readonly X: string,
-                                                    //   readonly Y: string,
-                                                    //   readonly Z: string
-                                                    // }
 ```
 
 ## Overview
@@ -79,7 +61,6 @@ License: MIT
 - [Type](#Type)
 - [Value](#Value)
 - [Script](#Script)
-- [Compile](#Compile)
 - [Schema](#Schema)
 - [Legacy](#Legacy)
 - [Contribute](#Contribute)
@@ -164,41 +145,37 @@ const A = Value.Parse(T, {                          // const A: {
 
 ## Script
 
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://tsplay.dev/Wk6L1m) | [Example 2](https://tsplay.dev/NnrJoN)
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/script/overview) | [Example 1](https://tsplay.dev/N9rQ8m) | [Example 2](https://tsplay.dev/NnrJoN)
 
-TypeBox is a runtime TypeScript DSL engine that can create, transform, and compute JSON Schema using native TypeScript syntax. The engine is implemented symmetrically at runtime and within the TypeScript type system, and is intended for use with the TypeScript 7 native compiler and above.
+TypeBox includes a runtime TypeScript DSL engine that can transform TypeScript syntax into JSON Schema. The engine is implemented at runtime and within the TypeScript type system.
 
 ```typescript
-// Scripted Type
-
+// ----------------------------------------------------------
+// Script
+// ----------------------------------------------------------
 const T = Type.Script(`{ 
   x: number, 
   y: string, 
   z: boolean 
-}`)                                                 // const T: TObject<{
-                                                    //   x: TNumber,
-                                                    //   y: TString,
-                                                    //   z: TBoolean
-                                                    // }>
-
-// JSON Schema Introspection
+}`)
 
+// ----------------------------------------------------------
+// Reflect
+// ----------------------------------------------------------
 T.type                                              // 'object'
 T.required                                          // ['x', 'y', 'z']
 T.properties                                        // { x: ..., y: ..., z: ... }
 
-// Scripted Type (Computed)
-
+// ----------------------------------------------------------
+// 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
+}`)
 
+// ----------------------------------------------------------
+// Inference
+// ----------------------------------------------------------
 type S = Type.Static<typeof S>                      // type S = {
                                                     //   x: number | null,
                                                     //   y: string | null,
@@ -206,50 +183,27 @@ type S = Type.Static<typeof S>                      // type S = {
                                                     // }
 ```
 
-<a name="Compile"></a>
-
-## Compile
-
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/compile/overview) | [Example](https://tsplay.dev/WyraZw)
-
-The Compile submodule is a high-performance, JSON Schema compliant JIT compiler that transforms schematics into efficient runtime validators. It is optimized for fast, dynamic schema compilation and delivers extremely high data-validation throughput.
+<a name="Schema"></a>
 
-```typescript
-import Compile from 'typebox/compile' 
-```
+## Schema
 
-### Example
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview)
 
-The following uses the compiler to Compile and Parse a value. 
+The Schema submodule is a low level JSON Schema spec compliant validation system that supports Drafts 3 through to 2020-12. This validation system is decoupled from both Type.* and Value.* submodules and is designed to be an ultra lightweight, high performance alternative to Ajv for compiling and validating with native JSON Schema.
 
 ```typescript
-const C = Compile(Type.Object({                     // const C: Validator<{}, TObject<{
-  x: Type.Number(),                                 //   x: TNumber,
-  y: Type.Number(),                                 //   y: TNumber,
-  z: Type.Number()                                  //   z: TNumber
-}))                                                 // }>>
-
-const A = C.Parse({                                 // const A: {
-  x: 0,                                             //   x: number,
-  y: 1,                                             //   y: number,
-  z: 0                                              //   z: number
-})                                                  // } = ...
+import Schema from 'typebox/schema'
 ```
 
-<a name="Schema"></a>
-
-## Schema
-
-[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview) | [Example 1](https://tsplay.dev/Wvrv3W) | [Example 2](https://tsplay.dev/m3g0ym)
-
-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.
+The following uses the Schema submodule to compile and parse from JSON Schema.
 
 ```typescript
-const C = Compile({
+// ----------------------------------------------------------
+// Compile
+// ----------------------------------------------------------
+const C = Schema.Compile({
   type: 'object',
   required: ['x', 'y', 'z'],
   properties: {
@@ -259,11 +213,14 @@ const C = Compile({
   }
 })
 
-const A = C.Parse({                                 // const A: {
-  x: 0,                                             //   x: number,
-  y: 0,                                             //   y: number,
-  z: 1                                              //   z: number
-})                                                  // } = ...
+// ----------------------------------------------------------
+// Parse
+// ----------------------------------------------------------
+const R = C.Parse({  x: 0, y: 0, z: 0 })            // const R: {
+                                                    //   x: number,
+                                                    //   y: number,
+                                                    //   z: number
+                                                    // } = ...
 ```
 
 ## Legacy
@@ -280,8 +237,9 @@ Most types created with 0.34.x are compatible with V1, and it is possible to run
 import { Type } from '@sinclair/typebox'            // TB: 0.34.x
 import { Static } from 'typebox'                    // TB: 1.0.0
 
+// ----------------------------------------------------------
 // Legacy Types
-
+// ----------------------------------------------------------
 const A = Type.Object({
   x: Type.Number(),
   y: Type.Number(),
@@ -296,8 +254,9 @@ const B = Type.Object({
 
 const C = Type.Composite([A, B])
 
+// ----------------------------------------------------------
 // Modern Inference
-
+// ----------------------------------------------------------
 type C = Static<typeof C>                           // type C = {
                                                     //   x: number;
                                                     //   y: number;
@@ -307,11 +266,12 @@ type C = Static<typeof C>                           // type C = {
                                                     //   c: number;
                                                     // }
 
+// ----------------------------------------------------------
 // Modern Compile
+// ----------------------------------------------------------
+import Schema from 'typebox/schema'
 
-import Compile from 'typebox/compile'
-
-const Result = Compile(C).Check({ ... })
+const R = Schema.Compile(C).Check({ ... })
 ```
 
 Revision 0.34.x is actively maintained at the following URL.