@sinclair/typebox 0.24.8 → 0.24.11

package/compiler/compiler.d.ts

@@ -3,10 +3,10 @@ import * as Types from '../typebox';
 export declare type CheckFunction = (value: unknown) => boolean;
 export declare class TypeCheck<T extends Types.TSchema> {
     private readonly schema;
-    private readonly additional;
+    private readonly references;
     private readonly checkFunc;
     private readonly code;
-    constructor(schema: T, additional: Types.TSchema[], checkFunc: CheckFunction, code: string);
+    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
     /** Returns the generated validation code used to validate this type. */
     Code(): string;
     /** Returns an iterator for each error in this value. */
@@ -14,6 +14,7 @@ export declare class TypeCheck<T extends Types.TSchema> {
     /** Returns true if the value matches the given type. */
     Check(value: unknown): value is Types.Static<T>;
 }
+/** Compiles TypeBox Types for Runtime Type Checking */
 export declare namespace TypeCompiler {
     /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
     function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;

package/compiler/compiler.js

@@ -35,12 +35,12 @@ const Types = require("../typebox");
 // -------------------------------------------------------------------
 class TypeCheck {
     schema;
-    additional;
+    references;
     checkFunc;
     code;
-    constructor(schema, additional, checkFunc, code) {
+    constructor(schema, references, checkFunc, code) {
         this.schema = schema;
-        this.additional = additional;
+        this.references = references;
         this.checkFunc = checkFunc;
         this.code = code;
     }
@@ -50,7 +50,7 @@ class TypeCheck {
     }
     /** Returns an iterator for each error in this value. */
     Errors(value) {
-        return errors_1.ValueErrors.Errors(this.schema, this.additional, value);
+        return errors_1.ValueErrors.Errors(this.schema, this.references, value);
     }
     /** Returns true if the value matches the given type. */
     Check(value) {
@@ -61,6 +61,7 @@ exports.TypeCheck = TypeCheck;
 // -------------------------------------------------------------------
 // TypeCompiler
 // -------------------------------------------------------------------
+/** Compiles TypeBox Types for Runtime Type Checking */
 var TypeCompiler;
 (function (TypeCompiler) {
     // -------------------------------------------------------------------
@@ -70,8 +71,14 @@ var TypeCompiler;
         yield '(true)';
     }
     function* Array(schema, value) {
-        const expr = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
-        yield `(Array.isArray(${value}) && ${value}.every(value => ${expr}))`;
+        const expression = [...Visit(schema.items, `value`)].map((condition) => condition).join(' && ');
+        if (schema.minItems !== undefined)
+            yield `(${value}.length >= ${schema.minItems})`;
+        if (schema.maxItems !== undefined)
+            yield `(${value}.length <= ${schema.maxItems})`;
+        if (schema.uniqueItems !== undefined)
+            yield `(new Set(${value}).size === ${value}.length)`;
+        yield `(Array.isArray(${value}) && ${value}.every(value => ${expression}))`;
     }
     function* Boolean(schema, value) {
         yield `(typeof ${value} === 'boolean')`;
@@ -84,15 +91,15 @@ var TypeCompiler;
     }
     function* Integer(schema, value) {
         yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if (schema.multipleOf)
+        if (schema.multipleOf !== undefined)
             yield `(${value} % ${schema.multipleOf} === 0)`;
-        if (schema.exclusiveMinimum)
+        if (schema.exclusiveMinimum !== undefined)
             yield `(${value} > ${schema.exclusiveMinimum})`;
-        if (schema.exclusiveMaximum)
+        if (schema.exclusiveMaximum !== undefined)
             yield `(${value} < ${schema.exclusiveMaximum})`;
-        if (schema.minimum)
+        if (schema.minimum !== undefined)
             yield `(${value} >= ${schema.minimum})`;
-        if (schema.maximum)
+        if (schema.maximum !== undefined)
             yield `(${value} <= ${schema.maximum})`;
     }
     function* Literal(schema, value) {
@@ -108,15 +115,15 @@ var TypeCompiler;
     }
     function* Number(schema, value) {
         yield `(typeof ${value} === 'number')`;
-        if (schema.multipleOf)
+        if (schema.multipleOf !== undefined)
             yield `(${value} % ${schema.multipleOf} === 0)`;
-        if (schema.exclusiveMinimum)
+        if (schema.exclusiveMinimum !== undefined)
             yield `(${value} > ${schema.exclusiveMinimum})`;
-        if (schema.exclusiveMaximum)
+        if (schema.exclusiveMaximum !== undefined)
             yield `(${value} < ${schema.exclusiveMaximum})`;
-        if (schema.minimum)
+        if (schema.minimum !== undefined)
             yield `(${value} >= ${schema.minimum})`;
-        if (schema.maximum)
+        if (schema.maximum !== undefined)
             yield `(${value} <= ${schema.maximum})`;
     }
     function* Object(schema, value) {
@@ -182,6 +189,12 @@ var TypeCompiler;
     }
     function* String(schema, value) {
         yield `(typeof ${value} === 'string')`;
+        if (schema.minLength !== undefined) {
+            yield `(${value}.length >= ${schema.minLength})`;
+        }
+        if (schema.maxLength !== undefined) {
+            yield `(${value}.length <= ${schema.maxLength})`;
+        }
         if (schema.pattern !== undefined) {
             const local = PushLocal(`const local = new RegExp('${schema.pattern}');`);
             yield `(${local}.test(${value}))`;
@@ -275,7 +288,7 @@ var TypeCompiler;
             case 'Void':
                 return yield* Void(anySchema, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`TypeCompiler: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     // -------------------------------------------------------------------
@@ -292,9 +305,9 @@ var TypeCompiler;
     function PushReferences(schemas = []) {
         for (const schema of schemas) {
             if (!schema.$id)
-                throw Error(`Referenced schemas must specify an $id. Failed for '${JSON.stringify(schema)}'`);
+                throw new Error(`TypeCompiler: Referenced schemas must specify an $id.`);
             if (referenceMap.has(schema.$id))
-                throw Error(`Duplicate schema $id detected for '${schema.$id}'`);
+                throw new Error(`TypeCompiler: Duplicate schema $id found for '${schema.$id}'`);
             referenceMap.set(schema.$id, schema);
         }
     }

package/compiler/index.d.ts

@@ -1,2 +1,2 @@
+export type { ValueError } from '../value/errors';
 export * from './compiler';
-export * from '../value/errors';

package/compiler/index.js

@@ -38,4 +38,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./compiler"), exports);
-__exportStar(require("../value/errors"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.8",
+  "version": "0.24.11",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",
@@ -21,6 +21,7 @@
     "format": "hammer task format",
     "start": "hammer task start",
     "test": "hammer task test",
+    "benchmark": "hammer task benchmark",
     "build": "hammer task build",
     "publish": "hammer task publish"
   },

package/readme.md

@@ -9,7 +9,9 @@
 <br />
 <br />
 
-[![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox) [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
+[![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
+[![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
+[![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>
 
@@ -339,7 +341,7 @@ The following table outlines the TypeBox mappings between TypeScript and JSON sc
 ```
 <a name="Modifiers"></a>
 
-### Modifiers
+## Modifiers
 
 TypeBox provides modifiers that can be applied to an objects properties. This allows for `optional` and `readonly` to be applied to that property. The following table illustates how they map between TypeScript and JSON Schema.
 
@@ -383,7 +385,7 @@ TypeBox provides modifiers that can be applied to an objects properties. This al
 
 <a name="Options"></a>
 
-### Options
+## Options
 
 You can pass additional JSON schema options on the last argument of any given type. The following are some examples.
 
@@ -400,7 +402,7 @@ const T = Type.Array(Type.Integer(), { minItems: 5 })
 
 <a name="Extended-Types"></a>
 
-### Extended Types
+## Extended Types
 
 In addition to JSON schema types, TypeBox provides several extended types that allow for `function` and `constructor` types to be composed. These additional types are not valid JSON Schema and will not validate using typical JSON Schema validation. However, these types can be used to frame JSON schema and describe callable interfaces that may receive JSON validated data. These types are as follows.
 
@@ -464,9 +466,9 @@ In addition to JSON schema types, TypeBox provides several extended types that a
 
 <a name="Reference-Types"></a>
 
-### Reference Types
+## Reference Types
 
-Types can be referenced with `Type.Ref(...)`. To reference a type, the target type must specify an `$id`.
+Use `Type.Ref(...)` to create referenced types. The target type must specify an `$id`.
 
 ```typescript
 const T = Type.String({ $id: 'T' })                  // const T = {
@@ -481,13 +483,13 @@ const R = Type.Ref(T)                                // const R = {
 
 <a name="Recursive-Types"></a>
 
-### Recursive Types
+## Recursive Types
 
-Recursive types can be created with the `Type.Recursive(...)` function.
+Use `Type.Recursive(...)` to create recursive types.
 
 ```typescript
 const Node = Type.Recursive(Node => Type.Object({    // const Node = {
-  id:    Type.String(),                              //   $id: "Node",
+  id: Type.String(),                                 //   $id: "Node",
   nodes: Type.Array(Node),                           //   type: "object",
 }), { $id: 'Node' })                                 //   properties: {
                                                      //     id: {
@@ -508,19 +510,20 @@ const Node = Type.Recursive(Node => Type.Object({    // const Node = {
 
 type Node = Static<typeof Node>                      // type Node = {
                                                      //   id: string
-                                                     //   nodes: ...
+                                                     //   nodes: ...[]
                                                      // }
 
-function visit(node: Node) {
-  for(const inner of node.nodes) {
-    visit(inner)
-  }
+function test(node: Node) {
+  const id = node.nodes[0].nodes[0].nodes[0]         // id is string
+                 .nodes[0].nodes[0].nodes[0]
+                 .nodes[0].nodes[0].nodes[0]
+                 .id
 }
 ```
 
 <a name="Generic-Types"></a>
 
-### Generic Types
+## Generic Types
 
 Generic types can be created using functions. The following creates a generic `Nullable<T>` type. 
 
@@ -552,9 +555,9 @@ type U = Static<typeof U>                            // type U = number | null
 
 <a name="Unsafe-Types"></a>
 
-### Unsafe Types
+## Unsafe Types
 
-In some cases, you may need schema definitions that are not provided by TypeBox. In these scenarios, it's common to want to define your own schema and static type inference rules. The `Type.Unsafe(...)` function provides this functionality, allowing you to specify both schema representation and a static type to infer. Consider the following which defines a `number` schema, but will infer as a `string`.
+Use `Type.Unsafe(...)` to create custom schemas with user defined inference rules.
 
 ```typescript
 const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
@@ -564,7 +567,7 @@ const T = Type.Unsafe<string>({ type: 'number' })    // const T = {
 type T = Static<typeof T>                            // type T = string
 ```
 
-The `Type.Unsafe(...)` function can be used with function generics to create custom schema representations for validators requiring specific schema representations. An example of which would be OpenAPI's `nullable` and `string-enum` representations which are not provided by TypeBox by default. The following demonstrates creating these schemas using the `Type.Unsafe(...)` function.
+The `Type.Unsafe(...)` function can be used to create schemas for validators that require specific schema representations. An example of this would be OpenAPI's `nullable` and `enum` schemas which are not provided by TypeBox. The following demonstrates using `Type.Unsafe(...)` to create these types.
 
 ```typescript
 import { Type, Static, TSchema } from '@sinclair/typebox'
@@ -605,9 +608,9 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 <a name="Values"></a>
 
-### Values
+## Values
 
-TypeBox can create values from types. It creates reasonable defaults for each value which can overrided by specifying a `default` value.
+Use `Value.Create(...)` to generate values from types.
 
 ```typescript
 import { Value } from '@sinclair/typebox/value'
@@ -623,8 +626,7 @@ const V = Value.Create(T)                            // const V = {
                                                      //   y: 0,
                                                      // }
 ```
-TypeBox also allows values to be upgraded to match the schematics of a given type. The `Value.Cast(...)` function can be used to upgrade a value into a target type while retaining as much information of the original value as possible. Casts are immutable operations.
-
+Use `Value.Cast(...)` to cast a value into a given type. This functionality can be helpful in data migrations.
 ```typescript
 import { Value } from '@sinclair/typebox/value'
 import { Type } from '@sinclair/typebox'
@@ -643,28 +645,26 @@ const C = Value.Cast(T, { x: 1, y: 2, z: 3 })          // const C = { x: 1, y: 2
 
 <a name="Guards"></a>
 
-### Guards
+## Guards
 
-If reflecting on TypeBox types, it can be helpful to test if a value matches a TypeBox schematic. This can be achieved using the TypeGuard namespace. The TypeGuard namespace offers exhaustive checks for each known TypeBox type.
+Use `TypeGuard.TSchema(...)` to check if a type is a valid TypeBox type. This functionality can be useful when reflecting types.
 
 ```typescript
 import { TypeGuard } from '@sinclair/typebox/guard'
 import { Type }  from '@sinclair/typebox'
 
-const T: any = {}                                    // T is any
-
-const { type } = T                                   // unsafe: type is any
+const T = Type.String()
 
 if(TypeGuard.TString(T)) {
     
-  const { type } = T                                 // safe: type is 'string'
+  // T is TString
 }
 
 ```
 
 <a name="Strict"></a>
 
-### Strict
+## Strict
 
 TypeBox schemas contain the `Kind` and `Modifier` symbol properties. These properties are provided to enable runtime type reflection on schemas, as well as helping TypeBox internally compose types. These properties are not strictly valid JSON schema; so in some cases it may be desirable to omit them. TypeBox provides a `Type.Strict()` function that will omit these properties if necessary.
 
@@ -693,7 +693,7 @@ const U = Type.Strict(T)                             // const U = {
 
 <a name="Validation"></a>
 
-### Validation
+## Validation
 
 TypeBox schemas target JSON Schema draft 6 so any validator capable of draft 6 should be fine. A good library to use for validation in JavaScript environments is [AJV](https://www.npmjs.com/package/ajv). The following example shows setting up AJV 7 to work with TypeBox.
 
@@ -745,7 +745,7 @@ const T = Type.Object({
   x: Type.Number(),
   y: Type.Number(),
   z: Type.Number(),
-}, { additionalProperties: false })
+})
 
 //--------------------------------------------------------------------------------------------
 //
@@ -753,73 +753,101 @@ const T = Type.Object({
 //
 //--------------------------------------------------------------------------------------------
 
-const OK = ajv.validate(T, { 
-  x: 1,
-  y: 2,
-  z: 3
-}) // -> true
+const R = ajv.validate(T, { x: 1, y: 2, z: 3 })      // const R = true
 ```
 
 Please refer to the official AJV [documentation](https://ajv.js.org/guide/getting-started.html) for additional information on using AJV.
 
 <a name="Compiler"></a>
 
-### Compiler
+## Compiler
+
+TypeBox provides a high performance runtime type checker that can be used in applications that need extremely fast message validation. This type checker is optimized for TypeBox types whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>`; please consider AJV.
 
-TypeBox includes a specialized `TypeCompiler` that can be used as a runtime type checker in lieu of a JSON Schema validator. This compiler is optimized for high throughput Web Socket messaging and can perform better than AJV for some structural checks. Please note that this compiler is not fully JSON Schema compliant and is limited to known TypeBox types only. The `TypeCompiler` contains a `Compile(T)` function that returns a `TypeCheck<T>` object that can be used to test the validity of a value as well as obtain errors.
+The following demonstrates its use.
 
 ```typescript
 import { TypeCompiler } from '@sinclair/typebox/compiler'
 import { Type } from '@sinclair/typebox'
 
-const T = Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-})
-
-const C = TypeCompiler.Compile(T)
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
 
-const OK = C.Check({ 
-  x: 1, 
-  y: 2, 
-  z: 3 
-}) // -> true
+const R = C.Check({ x: 1, y: 2, z: 3 })              // const R = true 
 ```
-Errors can be obtained by calling the `Errors(...)` function. This function returns an iterator that may contain zero or more errors for the given value. For performance, you should only call `Errors(V)` if the `Check(V)` function returns `false`. 
+
+Validation errors can be read with the `Errors(...)` function.
+
 ```typescript
-const C = TypeCompiler.Compile(Type.Object({
-  x: Type.Number(),
-  y: Type.Number(),
-  z: Type.Number()
-}))
+const C = TypeCompiler.Compile(Type.Object({         // const C: TypeCheck<TObject<{
+  x: Type.Number(),                                  //     x: TNumber;
+  y: Type.Number(),                                  //     y: TNumber;
+  z: Type.Number()                                   //     z: TNumber;
+}))                                                  // }>>
 
-const V = { } // invalid
+const value = { ... }
 
-if(!C.Check(V)) {
-  for(const error of C.Errors(V)) {
-    console.log(error)
+if(!C.Check(value)) {
+  for(const { message } of C.Errors(value)) {
+    console.log(message)
   }
 }
 ```
-The TypeCompiler generates JavaScript validation routines types that are evaluated at runtime. You can inspect the generated code by calling the `Code()` function of the `TypeCheck<T>` object.
+
+Compiled routines can be inspected with the `.Code()` function.
 
 ```typescript
-const C = TypeCompiler.Compile(Type.String())
+const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
 
-console.log(C.Code())
-//
-// outputs:
-//
-// return function check(value) {
-//   return (
-//     (typeof value === 'string')
-//  )
-// }
+console.log(C.Code())                                // return function check(value) {
+                                                     //   return (
+                                                     //     (typeof value === 'string')
+                                                     //   )
+                                                     // }
+```
+
+### Benchmarks
+
+The following table shows comparative benchmarks between TypeBox and Ajv. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`.
+
+```typescript
+┌──────────────────┬────────────┬──────────┬──────────┬─────────────┐
+│     (index)      │ Iterations │   Ajv    │ TypeBox  │ Performance │
+├──────────────────┼────────────┼──────────┼──────────┼─────────────┤
+│      RegEx       │  16000000  │ '681ms'  │ '510ms'  │   '+33%'    │
+│     ObjectA      │  16000000  │ '427ms'  │ '300ms'  │   '+42%'    │
+│     ObjectB      │  16000000  │ '680ms'  │ '458ms'  │   '+48%'    │
+│      Tuple       │  16000000  │ '286ms'  │ '190ms'  │   '+50%'    │
+│      Union       │  16000000  │ '300ms'  │ '207ms'  │   '+44%'    │
+│    Recursive     │  16000000  │ '5330ms' │ '1994ms' │   '+167%'   │
+│     Vector4      │  16000000  │ '292ms'  │ '168ms'  │   '+73%'    │
+│     Matrix4      │  16000000  │ '586ms'  │ '382ms'  │   '+53%'    │
+│ Literal<String>  │  16000000  │ '251ms'  │ '152ms'  │   '+65%'    │
+│ Literal<Number>  │  16000000  │ '241ms'  │ '147ms'  │   '+63%'    │
+│ Literal<Boolean> │  16000000  │ '239ms'  │ '152ms'  │   '+57%'    │
+│  Array<Number>   │  16000000  │ '432ms'  │ '235ms'  │   '+83%'    │
+│  Array<String>   │  16000000  │ '430ms'  │ '300ms'  │   '+43%'    │
+│  Array<Boolean>  │  16000000  │ '490ms'  │ '354ms'  │   '+38%'    │
+│  Array<ObjectA>  │  16000000  │ '3537ms' │ '2107ms' │   '+67%'    │
+│  Array<ObjectB>  │  16000000  │ '6366ms' │ '4556ms' │   '+39%'    │
+│   Array<Tuple>   │  16000000  │ '1382ms' │ '1038ms' │   '+33%'    │
+│  Array<Vector4>  │  16000000  │ '1429ms' │ '767ms'  │   '+86%'    │
+│  Array<Matrix4>  │  16000000  │ '6029ms' │ '4119ms' │   '+46%'    │
+│       Any        │  16000000  │ '232ms'  │ '149ms'  │   '+55%'    │
+│     Boolean      │  16000000  │ '233ms'  │ '149ms'  │   '+56%'    │
+│     Integer      │  16000000  │ '244ms'  │ '154ms'  │   '+58%'    │
+│       Null       │  16000000  │ '230ms'  │ '149ms'  │   '+54%'    │
+│      Number      │  16000000  │ '227ms'  │ '145ms'  │   '+56%'    │
+│      String      │  16000000  │ '230ms'  │ '150ms'  │   '+53%'    │
+│     Unknown      │  16000000  │ '231ms'  │ '147ms'  │   '+57%'    │
+└──────────────────┴────────────┴──────────┴──────────┴─────────────┘
 ```
 
 <a name="Contribute"></a>
 
-### Contribute
+## Contribute
 
 TypeBox is open to community contribution. Please ensure you submit an open issue before submitting your pull request. The TypeBox project preferences open community discussion prior to accepting new features.

package/typebox.js

@@ -227,7 +227,7 @@ class TypeBuilder {
     /** Creates a reference schema */
     Ref(schema, options = {}) {
         if (schema.$id === undefined)
-            throw Error('Cannot create reference schema as target schema as has no $id');
+            throw Error('Type.Ref: Referenced schema must specify an $id');
         return this.Create({ ...options, [exports.Kind]: 'Ref', $ref: schema.$id });
     }
     /** Creates a string type from a regular expression */

package/value/cast.js

@@ -72,7 +72,6 @@ var UnionValueCast;
 })(UnionValueCast || (UnionValueCast = {}));
 var ValueCast;
 (function (ValueCast) {
-    const ids = new Map();
     function Any(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
@@ -121,7 +120,6 @@ var ValueCast;
             return value;
         if (value === null || typeof value !== 'object')
             return create_1.ValueCreate.Create(schema, references);
-        ids.set(schema.$id, schema);
         const required = new Set(schema.required || []);
         const result = {};
         for (const [key, property] of globalThis.Object.entries(schema.properties)) {
@@ -148,7 +146,7 @@ var ValueCast;
         return result;
     }
     function Recursive(schema, references, value) {
-        throw Error('Cannot patch recursive schemas');
+        throw new Error('CastValue.Recursive: Cannot cast recursive schemas');
     }
     function Ref(schema, references, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
@@ -240,7 +238,7 @@ var ValueCast;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw Error(`ValueCast.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     ValueCast.Visit = Visit;

package/value/check.js

@@ -38,6 +38,15 @@ var ValueCheck;
         if (!globalThis.Array.isArray(value)) {
             return false;
         }
+        if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+            return false;
+        }
+        if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+            return false;
+        }
+        if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+            return false;
+        }
         return value.every((val) => Visit(schema.items, references, val));
     }
     function Boolean(schema, references, value) {
@@ -56,19 +65,19 @@ var ValueCheck;
         if (!globalThis.Number.isInteger(value)) {
             return false;
         }
-        if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
+        if (schema.multipleOf !== undefined && !(value % schema.multipleOf === 0)) {
             return false;
         }
-        if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
+        if (schema.exclusiveMinimum !== undefined && !(value > schema.exclusiveMinimum)) {
             return false;
         }
-        if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
+        if (schema.exclusiveMaximum !== undefined && !(value < schema.exclusiveMaximum)) {
             return false;
         }
-        if (schema.minimum && !(value >= schema.minimum)) {
+        if (schema.minimum !== undefined && !(value >= schema.minimum)) {
             return false;
         }
-        if (schema.maximum && !(value <= schema.maximum)) {
+        if (schema.maximum !== undefined && !(value <= schema.maximum)) {
             return false;
         }
         return true;
@@ -176,6 +185,14 @@ var ValueCheck;
         if (!(typeof value === 'string')) {
             return false;
         }
+        if (schema.minLength !== undefined) {
+            if (!(value.length >= schema.minLength))
+                return false;
+        }
+        if (schema.maxLength !== undefined) {
+            if (!(value.length <= schema.maxLength))
+                return false;
+        }
         if (schema.pattern !== undefined) {
             const regex = new RegExp(schema.pattern);
             if (!regex.test(value))
@@ -273,7 +290,7 @@ var ValueCheck;
             case 'Void':
                 return Void(anySchema, anyReferences, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`CheckValue: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     // -------------------------------------------------------------------------

package/value/create.js

@@ -40,7 +40,10 @@ var ValueCreate;
         }
     }
     function Array(schema, references) {
-        if (schema.default !== undefined) {
+        if (schema.uniqueItems === true && schema.default === undefined) {
+            throw new Error('ValueCreate.Array: Arrays with uniqueItems require a default value');
+        }
+        else if (schema.default !== undefined) {
             return schema.default;
         }
         else if (schema.minItems !== undefined) {
@@ -70,8 +73,8 @@ var ValueCreate;
                 return class {
                     constructor() {
                         for (const [key, val] of globalThis.Object.entries(value)) {
-                            const facade = this;
-                            facade[key] = val;
+                            const self = this;
+                            self[key] = val;
                         }
                     }
                 };
@@ -87,7 +90,7 @@ var ValueCreate;
             return schema.default;
         }
         else if (schema.anyOf.length === 0) {
-            throw new Error('Cannot create default enum value as this enum has no items');
+            throw new Error('ValueCreate.Enum: Cannot create default enum value as this enum has no items');
         }
         else {
             return schema.anyOf[0].const;
@@ -169,7 +172,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            throw new Error('Rec types require a default value');
+            throw new Error('ValueCreate.Recursive: Recursive types require a default value');
         }
     }
     function Ref(schema, references) {
@@ -197,7 +200,7 @@ var ValueCreate;
     function String(schema, references) {
         if (schema.pattern !== undefined) {
             if (schema.default === undefined) {
-                throw Error('String types with patterns must specify a default value');
+                throw new Error('ValueCreate.String: String types with patterns must specify a default value');
             }
             else {
                 return schema.default;
@@ -207,6 +210,11 @@ var ValueCreate;
             if (schema.default !== undefined) {
                 return schema.default;
             }
+            else if (schema.minLength !== undefined) {
+                return globalThis.Array.from({ length: schema.minLength })
+                    .map(() => '.')
+                    .join('');
+            }
             else {
                 return '';
             }
@@ -231,7 +239,7 @@ var ValueCreate;
             return schema.default;
         }
         else if (schema.anyOf.length === 0) {
-            throw Error('Cannot generate Union with empty set');
+            throw new Error('ValueCreate.Union: Cannot create Union with zero variants');
         }
         else {
             return ValueCreate.Create(schema.anyOf[0], references);
@@ -241,7 +249,7 @@ var ValueCreate;
         if (schema.default !== undefined) {
             return schema.default;
         }
-        else if (schema.minByteLength) {
+        else if (schema.minByteLength !== undefined) {
             return new globalThis.Uint8Array(schema.minByteLength);
         }
         else {
@@ -311,7 +319,7 @@ var ValueCreate;
             case 'Void':
                 return Void(anySchema, anyReferences);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`ValueCreate.Visit: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     ValueCreate.Visit = Visit;

package/value/errors.js

@@ -36,6 +36,15 @@ var ValueErrors;
         if (!globalThis.Array.isArray(value)) {
             return yield { schema, path, value, message: `Expected array` };
         }
+        if (schema.minItems !== undefined && !(value.length >= schema.minItems)) {
+            yield { schema, path, value, message: `Expected array length to be greater or equal to ${schema.minItems}` };
+        }
+        if (schema.maxItems !== undefined && !(value.length <= schema.maxItems)) {
+            yield { schema, path, value, message: `Expected array length to be less or equal to ${schema.maxItems}` };
+        }
+        if (schema.uniqueItems === true && !(new Set(value).size === value.length)) {
+            yield { schema, path, value, message: `Expected array elements to be unique` };
+        }
         for (let i = 0; i < value.length; i++) {
             yield* Visit(schema.items, references, `${path}/${i}`, value[i]);
         }
@@ -159,19 +168,25 @@ var ValueErrors;
     function* Ref(schema, references, path, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new Error(`ValueErrors.Ref: Cannot find schema with $id '${schema.$ref}'.`);
         yield* Visit(reference, references, path, value);
     }
     function* Self(schema, references, path, value) {
         const reference = references.find((reference) => reference.$id === schema.$ref);
         if (reference === undefined)
-            throw new Error(`CheckValue.Ref: Cannot find schema with $id '${schema.$ref}'.`);
+            throw new Error(`ValueErrors.Self: Cannot find schema with $id '${schema.$ref}'.`);
         yield* Visit(reference, references, path, value);
     }
     function* String(schema, references, path, value) {
         if (!(typeof value === 'string')) {
             return yield { schema, path, value, message: 'Expected string' };
         }
+        if (schema.minLength !== undefined && !(value.length >= schema.minLength)) {
+            yield { schema, path, value, message: `Expected string length greater or equal to ${schema.minLength}` };
+        }
+        if (schema.maxLength !== undefined && !(value.length <= schema.maxLength)) {
+            yield { schema, path, value, message: `Expected string length less or equal to ${schema.maxLength}` };
+        }
         if (schema.pattern !== undefined) {
             const regex = new RegExp(schema.pattern);
             if (!regex.test(value)) {
@@ -280,7 +295,7 @@ var ValueErrors;
             case 'Void':
                 return yield* Void(anySchema, anyReferences, path, value);
             default:
-                throw Error(`Unknown schema kind '${schema[Types.Kind]}'`);
+                throw new Error(`ValueErrors: Unknown schema kind '${schema[Types.Kind]}'`);
         }
     }
     function* Errors(schema, references, value) {

package/value/index.d.ts

@@ -1 +1,2 @@
+export type { ValueError } from './errors';
 export * from './value';