@sinclair/typebox 0.34.8 → 0.34.9

package/build/cjs/compiler/compiler.d.ts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/cjs/compiler/compiler.js

@@ -36,6 +36,14 @@ class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return (0, index_2.Errors)(this.schema, this.references, value);

package/build/cjs/value/parse/parse.d.ts

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index';
 import { TSchema } from '../../type/schema/index';
 import { StaticDecode } from '../../type/static/index';
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/cjs/value/parse/parse.js

@@ -1,29 +1,85 @@
 "use strict";
 
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDefault = exports.ParseRegistry = exports.ParseError = void 0;
 exports.Parse = Parse;
-const index_1 = require("../transform/index");
-const assert_1 = require("../assert/assert");
-const default_1 = require("../default/default");
-const convert_1 = require("../convert/convert");
-const clean_1 = require("../clean/clean");
-const index_2 = require("../clone/index");
+const index_1 = require("../../type/error/index");
+const index_2 = require("../transform/index");
+const index_3 = require("../assert/index");
+const index_4 = require("../default/index");
+const index_5 = require("../convert/index");
+const index_6 = require("../clean/index");
+const index_7 = require("../clone/index");
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+const index_8 = require("../guard/index");
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+class ParseError extends index_1.TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.ParseError = ParseError;
+// prettier-ignore
+var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => (0, index_7.Clone)(value)],
+        ['Clean', (type, references, value) => (0, index_6.Clean)(type, references, value)],
+        ['Default', (type, references, value) => (0, index_4.Default)(type, references, value)],
+        ['Convert', (type, references, value) => (0, index_5.Convert)(type, references, value)],
+        ['Assert', (type, references, value) => { (0, index_3.Assert)(type, references, value); return value; }],
+        ['Decode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformDecode)(type, references, value) : value)],
+        ['Encode', (type, references, value) => ((0, index_2.HasTransform)(type, references) ? (0, index_2.TransformEncode)(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (exports.ParseRegistry = ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => (0, index_2.Clone)(value),
-    (schema, references, value) => (0, default_1.Default)(schema, references, value),
-    (schema, references, value) => (0, clean_1.Clean)(schema, references, value),
-    (schema, references, value) => (0, convert_1.Convert)(schema, references, value),
-    (schema, references, value) => { (0, assert_1.Assert)(schema, references, value); return value; },
-    (schema, references, value) => ((0, index_1.HasTransform)(schema, references) ? (0, index_1.TransformDecode)(schema, references, value) : value),
+exports.ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
 ];
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue(schema, references, value) {
-    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if ((0, index_8.IsUndefined)(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
 }
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value */
 function Parse(...args) {
-    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? (0, index_8.IsArray)(args[0]) ? [args[0], args[1], [], args[2]] : [exports.ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [exports.ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/build/esm/compiler/compiler.d.mts

@@ -12,6 +12,10 @@ export declare class TypeCheck<T extends TSchema> {
     constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated assertion code used to validate this type. */
     Code(): string;
+    /** Returns the schema type used to validate */
+    Schema(): T;
+    /** Returns reference types used to validate */
+    References(): TSchema[];
     /** Returns an iterator for each error in this value. */
     Errors(value: unknown): ValueErrorIterator;
     /** Returns true if the value matches the compiled type. */

package/build/esm/compiler/compiler.mjs

@@ -32,6 +32,14 @@ export class TypeCheck {
     Code() {
         return this.code;
     }
+    /** Returns the schema type used to validate */
+    Schema() {
+        return this.schema;
+    }
+    /** Returns reference types used to validate */
+    References() {
+        return this.references;
+    }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
         return Errors(this.schema, this.references, value);

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

@@ -1,6 +1,22 @@
+import { TypeBoxError } from '../../type/error/index.mjs';
 import { TSchema } from '../../type/schema/index.mjs';
 import { StaticDecode } from '../../type/static/index.mjs';
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, references: TSchema[], value: unknown): R;
-/** Parses a value or throws an `AssertError` if invalid. */
-export declare function Parse<T extends TSchema, R = StaticDecode<T>>(schema: T, value: unknown): R;
+export declare class ParseError extends TypeBoxError {
+    constructor(message: string);
+}
+export type TParseOperation = 'Clone' | 'Clean' | 'Default' | 'Convert' | 'Assert' | 'Decode' | ({} & string);
+export type TParseFunction = (type: TSchema, references: TSchema[], value: unknown) => unknown;
+export declare namespace ParseRegistry {
+    function Delete(key: string): void;
+    function Set(key: string, callback: TParseFunction): void;
+    function Get(key: string): TParseFunction | undefined;
+}
+export declare const ParseDefault: readonly ["Clone", "Clean", "Default", "Convert", "Assert", "Decode"];
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, references: TSchema[], value: unknown): Result;
+/** Parses a value using the default parse pipeline. Will throws an `AssertError` if invalid. */
+export declare function Parse<Type extends TSchema, Output = StaticDecode<Type>, Result extends Output = Output>(schema: Type, value: unknown): Result;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, references: TSchema[], value: unknown): unknown;
+/** Parses a value using the specified operations. */
+export declare function Parse<Type extends TSchema>(operations: TParseOperation[], schema: Type, value: unknown): unknown;

package/build/esm/value/parse/parse.mjs

@@ -1,25 +1,79 @@
-import { TransformDecode, HasTransform } from '../transform/index.mjs';
-import { Assert } from '../assert/assert.mjs';
-import { Default } from '../default/default.mjs';
-import { Convert } from '../convert/convert.mjs';
-import { Clean } from '../clean/clean.mjs';
+import { TypeBoxError } from '../../type/error/index.mjs';
+import { TransformDecode, TransformEncode, HasTransform } from '../transform/index.mjs';
+import { Assert } from '../assert/index.mjs';
+import { Default } from '../default/index.mjs';
+import { Convert } from '../convert/index.mjs';
+import { Clean } from '../clean/index.mjs';
 import { Clone } from '../clone/index.mjs';
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+import { IsArray, IsUndefined } from '../guard/index.mjs';
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export class ParseError extends TypeBoxError {
+    constructor(message) {
+        super(message);
+    }
+}
+// prettier-ignore
+export var ParseRegistry;
+(function (ParseRegistry) {
+    const registry = new Map([
+        ['Clone', (_type, _references, value) => Clone(value)],
+        ['Clean', (type, references, value) => Clean(type, references, value)],
+        ['Default', (type, references, value) => Default(type, references, value)],
+        ['Convert', (type, references, value) => Convert(type, references, value)],
+        ['Assert', (type, references, value) => { Assert(type, references, value); return value; }],
+        ['Decode', (type, references, value) => (HasTransform(type, references) ? TransformDecode(type, references, value) : value)],
+        ['Encode', (type, references, value) => (HasTransform(type, references) ? TransformEncode(type, references, value) : value)],
+    ]);
+    // Deletes an entry from the registry
+    function Delete(key) {
+        registry.delete(key);
+    }
+    ParseRegistry.Delete = Delete;
+    // Sets an entry in the registry
+    function Set(key, callback) {
+        registry.set(key, callback);
+    }
+    ParseRegistry.Set = Set;
+    // Gets an entry in the registry
+    function Get(key) {
+        return registry.get(key);
+    }
+    ParseRegistry.Get = Get;
+})(ParseRegistry || (ParseRegistry = {}));
+// ------------------------------------------------------------------
+// Default Parse Sequence
+// ------------------------------------------------------------------
 // prettier-ignore
-const ParseReducer = [
-    (_schema, _references, value) => Clone(value),
-    (schema, references, value) => Default(schema, references, value),
-    (schema, references, value) => Clean(schema, references, value),
-    (schema, references, value) => Convert(schema, references, value),
-    (schema, references, value) => { Assert(schema, references, value); return value; },
-    (schema, references, value) => (HasTransform(schema, references) ? TransformDecode(schema, references, value) : value),
+export const ParseDefault = [
+    'Clone',
+    'Clean',
+    'Default',
+    'Convert',
+    'Assert',
+    'Decode'
 ];
 // ------------------------------------------------------------------
 // ParseValue
 // ------------------------------------------------------------------
-function ParseValue(schema, references, value) {
-    return ParseReducer.reduce((value, reducer) => reducer(schema, references, value), value);
+function ParseValue(operations, type, references, value) {
+    return operations.reduce((value, operationKey) => {
+        const operation = ParseRegistry.Get(operationKey);
+        if (IsUndefined(operation))
+            throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+        return operation(type, references, value);
+    }, value);
 }
-/** Parses a value or throws an `AssertError` if invalid. */
+/** Parses a value */
 export function Parse(...args) {
-    return args.length === 3 ? ParseValue(args[0], args[1], args[2]) : ParseValue(args[0], [], args[1]);
+    // prettier-ignore
+    const [operations, schema, references, value] = (args.length === 4 ? [args[0], args[1], args[2], args[3]] :
+        args.length === 3 ? IsArray(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] :
+            args.length === 2 ? [ParseDefault, args[0], [], args[1]] :
+                (() => { throw new ParseError('Invalid Arguments'); })());
+    return ParseValue(operations, schema, references, value);
 }

package/package.json

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

package/readme.md

@@ -78,9 +78,6 @@ License MIT
   - [Unsafe](#types-unsafe)
 - [Syntax](#syntax)
   - [Parse](#syntax-parse)
-  - [Compose](#syntax-compose)
-  - [Context](#syntax-context)
-  - [Module](#syntax-module)
   - [Static](#syntax-static)
   - [Limits](#syntax-limits)
 - [Values](#values)
@@ -1025,9 +1022,9 @@ if(TypeGuard.IsString(T)) {
 
 ## Syntax Types
 
-TypeBox provides support for parsing TypeScript syntax directly into TypeBox Json Schema schematics. Syntax Types offer a string based DSL frontend to TypeBox's Type Builder system and can be useful for converting existing TypeScript type definitions into Json Schema schematics without reimplementation via the Type Builder.
+Syntax Types is a feature that enables TypeBox to parse TypeScript type annotations directly into Json Schema. This feature works both at runtime and statically within the type system. Syntax Types use Json Schema as the Abstract Syntax Tree (AST) parse target for TypeScript types. Syntax Types are designed to offer a syntactical frontend to the standard Type Builder API.
 
-Syntax Types are provided via optional import.
+This feature is available via optional import.
 
 ```typescript
 import { Parse } from '@sinclair/typebox/syntax'
@@ -1037,7 +1034,7 @@ import { Parse } from '@sinclair/typebox/syntax'
 
 ### Parse
 
-Use the Parse function to convert a TypeScript string into a TypeBox type. TypeBox will infer the appropriate TSchema type or return undefined if there is a syntax error.
+Use the Parse function to transform a TypeScript type annotation into a TypeBox type. This function will return the parsed TypeBox type or undefined on error.
 
 ```typescript
 const A = Parse('string')                           // const A: TString
@@ -1054,45 +1051,46 @@ const C = Parse(`{ x: number, y: number }`)         // const C: TObject<{
                                                     // }>
 ```
 
-
-
-<a name='syntax-compose'></a>
-
-### Compose
-
-Syntax Types are designed to be interchangeable with standard Types.
+Syntax Types can be composed with Standard Types. 
 
 ```typescript
 const T = Type.Object({                             // const T: TObject<{
   x: Parse('number'),                               //   x: TNumber,
-  y: Parse('number'),                               //   y: TNumber,
-  z: Parse('number')                                //   z: TNumber
+  y: Parse('string'),                               //   y: TString,
+  z: Parse('boolean')                               //   z: TBoolean
 })                                                  // }>
 ```
 
-<a name='syntax-module'></a>
+It is also possible to pass Standard Types to Syntax Types in the following way.
 
-### Module
+```typescript
+const X = Type.Number()
+const Y = Type.String()
+const Z = Type.Boolean()
+
+const T = Parse({ X, Y, Z }, `{ 
+  x: X, 
+  y: Y, 
+  z: Z 
+}`)
+```
 
-Syntax Types also support Module parsing. This can provide a more terse syntax for creating Module definitions, but comes with an inference performance cost. Module parsing supports interface and type alias definitions. Generics types are currently unsupported. 
+Syntax Types can also be used to parse Module types.
 
 ```typescript
-const Module = Parse(`module {
-  
+const Foo = Parse(`module Foo {
+
+  export type PartialUser = Pick<User, 'id'> & Partial<Omit<User, 'id'>>
+
   export interface User {
     id: string
     name: string
     email: string
   }
- 
-  export type PartialUser = (
-    Pick<User, 'id'> &
-    Partial<Omit<User, 'id'>>
-  )
 
 }`)
 
-const PartialUser = Module.Import('PartialUser')    // TImport<{...}, 'PartialUser'>
+const PartialUser = Foo.Import('PartialUser')       // TImport<{...}, 'PartialUser'>
 
 type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     //   id: string,
@@ -1102,45 +1100,11 @@ type PartialUser = Static<typeof PartialUser>       // type PartialUser = {
                                                     // }
 ```
 
-<a name='syntax-context'></a>
-
-### Context
-
-The Parse function takes an optional leading Context object that contains external types. This Context allows the syntax to reference these external types using the property identifiers provided by the Context. The following passes the external type `T` to Parse.
-
-```typescript
-const T = Type.Object({                             // const T: TObject<{
-  x: Type.Number(),                                 //   x: TNumber,
-  y: Type.Number(),                                 //   y: TNumber,
-  z: Type.Number()                                  //   z: TNumber
-})                                                  // }>
-
-const A = Parse({ T }, 'Partial<T>')                // const A: TObject<{
-                                                    //   x: TOptional<TNumber>,
-                                                    //   y: TOptional<TNumber>,
-                                                    //   z: TOptional<TNumber>
-                                                    // }>
-
-const B = Parse({ T }, 'keyof T')                   // const B: TUnion<[
-                                                    //   TLiteral<'x'>,
-                                                    //   TLiteral<'y'>,
-                                                    //   TLiteral<'z'>
-                                                    // ]>
-
-const C = Parse({ T }, 'T & { w: number }')         // const C: TIntersect<[TObject<{
-                                                    //    x: TNumber;
-                                                    //    y: TNumber;
-                                                    //    z: TNumber;
-                                                    // }>, TObject<{
-                                                    //    w: TNumber;
-                                                    // }>]>
-```
-
 <a name='syntax-static'></a>
 
 ### Static
 
-Syntax Types provide two Static types for inferring TypeScript types and TypeBox schematics from strings.
+Syntax Types provide two Static types specific to inferring TypeBox and TypeScript types from strings.
 
 ```typescript
 import { StaticParseAsSchema, StaticParseAsType } from '@sinclair/typebox/syntax' 
@@ -1154,8 +1118,8 @@ type S = StaticParseAsSchema<{}, '{ x: number }'>   // type S: TObject<{
 // Will infer as a type
 
 type T = StaticParseAsType<{}, '{ x: number }'>     // type T = {
-                                                    //  x: number
-                                                    //                       
+                                                    //   x: number
+                                                    // }                      
 ```
 
 
@@ -1361,26 +1325,28 @@ const B = Value.Encode(Type.String(), 42)             // throw
 
 ### Parse
 
-Use the Parse function to parse a value or throw if invalid. This function internally uses Default, Clean, Convert and Decode to make a best effort attempt to parse the value into the expected type. This function should not be used in performance critical code paths.
+Use the Parse function to parse a value. This function calls the `Clone` `Clean`, `Default`, `Convert`, `Assert` and `Decode` Value functions in this exact order to process a value.
 
 ```typescript
-const T = Type.Object({ x: Type.Number({ default: 0 }), y: Type.Number({ default: 0 }) })
+const R = Value.Parse(Type.String(), 'hello')      // const R: string = "hello"
 
-// Default
+const E = Value.Parse(Type.String(), undefined)    // throws AssertError 
+```
 
-const A = Value.Parse(T, { })                                 // const A = { x: 0, y: 0 }
+You can override the order in which functions are are run, or omit functions entirely in the following way.
 
-// Convert
+```typescript
+// Runs no functions.
 
-const B = Value.Parse(T, { x: '1', y: '2' })                  // const B = { x: 1, y: 2 }
+const R = Value.Parse([], Type.String(), 12345)
 
-// Clean
+// Runs the Assert() function.
 
-const C = Value.Parse(T, { x: 1, y: 2, z: 3 })                // const C = { x: 1, y: 2 }
+const E = Value.Parse(['Assert'], Type.String(), 12345)
 
-// Assert
+// Runs the Convert() function followed by the Assert() function.
 
-const D = Value.Parse(T, undefined)                           // throws AssertError
+const S = Value.Parse(['Convert', 'Assert'], Type.String(), 12345)
 ```
 
 <a name='values-equal'></a>