typebox 1.0.81 → 1.1.1

package/build/compile/validator.mjs

@@ -1,8 +1,9 @@
 // deno-fmt-ignore-file
+import { Settings } from '../system/settings/index.mjs';
 import { Arguments } from '../system/arguments/index.mjs';
 import { Environment } from '../system/environment/index.mjs';
 import { Base } from '../type/index.mjs';
-import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser } from '../value/index.mjs';
+import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
 // ------------------------------------------------------------------
 // Validator<...>
@@ -93,13 +94,14 @@ export class Validator extends Base {
     Clone() {
         return new Validator(this.context, this.type, this.isEvaluated, this.hasCodec, this.code, this.check);
     }
-    // ----------------------------------------------------------------
-    // Parse | Decode | Encode
-    // ----------------------------------------------------------------
     /** Parses a value */
     Parse(value) {
-        const result = this.Check(value) ? value : Parser(this.context, this.type, value);
-        return result;
+        const checked = this.Check(value);
+        if (checked)
+            return value;
+        if (Settings.Get().correctiveParse)
+            return Parser(this.context, this.type, value);
+        throw new ParseError(value, this.Errors(value));
     }
     /** Decodes a value */
     Decode(value) {

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.Context(), this.build.Schema(), 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/system/settings/settings.d.mts

@@ -38,6 +38,15 @@ export interface TSettings {
      * @default false
      */
     enumerableKind: boolean;
+    /**
+     * Controls whether TypeBox uses corrective Parse. When enabled, TypeBox will attempt to recover invalid
+     * values during Parse by running a sequence of `Value.*` operations to `Convert`, `Default`, and `Clean`
+     * the value, followed by a subsequent `Assert`. Enabling this option may incur significant performance
+     * overhead for invalid values. It is recommended to keep this disabled in performance-sensitive
+     * applications.
+     * @default false
+     */
+    correctiveParse: boolean;
 }
 /** Resets system settings to defaults */
 export declare function Reset(): void;

package/build/system/settings/settings.mjs

@@ -5,7 +5,8 @@ const settings = {
     maxErrors: 8,
     useEval: true,
     exactOptionalPropertyTypes: false,
-    enumerableKind: false
+    enumerableKind: false,
+    correctiveParse: false
 };
 /** Resets system settings to defaults */
 export function Reset() {
@@ -14,6 +15,7 @@ export function Reset() {
     settings.useEval = true;
     settings.exactOptionalPropertyTypes = false;
     settings.enumerableKind = false;
+    settings.correctiveParse = false;
 }
 /** Sets system settings */
 export function Set(options) {

package/build/value/parse/parse.d.mts

@@ -5,17 +5,7 @@ export declare class ParseError extends AssertError {
     constructor(value: unknown, errors: TLocalizedValidationError[]);
 }
 export declare const Parser: import("../pipeline/pipeline.mjs").PipelineInterface;
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
+/**  Parses a value with the given type. */
 export declare function Parse<const Type extends TSchema, Result extends unknown = StaticParse<Type>>(type: Type, value: unknown): Result;
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
+/**  Parses a value with the given type. */
 export declare function Parse<Context extends TProperties, const Type extends TSchema, Result extends unknown = StaticParse<Type, Context>>(context: Context, type: Type, value: unknown): Result;

package/build/value/parse/parse.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { Settings } from '../../system/system.mjs';
 import { Arguments } from '../../system/arguments/index.mjs';
 import { AssertError } from '../assert/index.mjs';
 import { Check } from '../check/index.mjs';
@@ -31,17 +32,16 @@ export const Parser = Pipeline([
     (context, type, value) => Clean(context, type, value),
     (context, type, value) => Assert(context, type, value)
 ]);
-/**
- * Parses a value with the given type. The function will Check the value and return
- * early if it matches the provided type. If the value does not match, it is processed
- * through a sequence of Clone, Default, Convert, and Clean operations and checked again.
- * A `ParseError` is thrown if the value fails to match after the processing sequence.
- */
+/**  Parses a value with the given type. */
 export function Parse(...args) {
     const [context, type, value] = Arguments.Match(args, {
         3: (context, type, value) => [context, type, value],
         2: (type, value) => [{}, type, value],
     });
-    const result = Check(context, type, value) ? value : Parser(context, type, value);
-    return result;
+    const checked = Check(context, type, value);
+    if (checked)
+        return value;
+    if (Settings.Get().correctiveParse)
+        return Parser(context, type, value);
+    throw new ParseError(value, Errors(context, type, value));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "Json Schema Type Builder with Static Type Resolution for TypeScript",
-  "version": "1.0.81",
+  "version": "1.1.1",
   "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.
-
-```typescript
-import Compile from 'typebox/compile' 
-```
+<a name="Schema"></a>
 
-### Example
+## Schema
 
-The following uses the compiler to Compile and Parse a value. 
+[Documentation](https://sinclairzx81.github.io/typebox/#/docs/schema/overview)
 
 ```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.
+The Value submodule is developed over a more low level JSON Schema spec compliant validation system that supports Drafts 3 through to 2020-12. This validation system is entirely decoupled from both Type and Value submodules and is designed to be a ultra lightweight, high performance alternative to Ajv.
 
 ### 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.