@sinclair/typebox 0.24.9 → 0.24.12

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. */

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) {
@@ -71,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')`;
@@ -85,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) {
@@ -109,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) {
@@ -183,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}))`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.9",
+  "version": "0.24.12",
   "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"
   },
@@ -29,7 +30,7 @@
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.1.0",
     "@types/node": "^17.0.12",
-    "ajv": "^8.9.0",
+    "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
     "chai": "^4.3.5",
     "mocha": "^9.2.0",

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 scenarios, you may need specific schemas not provided by TypeBox. In these cases, it's common to want to define a custom schema with custom static inference rules. The `Type.Unsafe(...)` function provides this functionality. This function enables one to specify both schema representation and a static type to infer. Consider the following which defines a `number` schema but infers as `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 combined with function generics to create user defined schemas for validators that need specific schema representations. An example of this might be the OpenAPI `nullable` and `string-enum` schema representations which are not provided by TypeBox. 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.
 ```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 a `TypeGuard` to test if a value meets a TypeBox type specification. Guards can be helpful 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,146 @@ 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 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.
+TypeBox provides an optional high performance runtime type checker that can be used in applications that require extremely fast validation. This type checker is optimized for TypeBox types only whose schematics are known in advance. If defining custom schemas with `Type.Unsafe<T>` please consider AJV.
+
+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 value = { }
+
+const errors = [...C.Errors(value)]                  // const errors = [{
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/x',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/y',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }, {
+                                                     //   schema: { type: 'number' },
+                                                     //   path: '/z',
+                                                     //   value: undefined,
+                                                     //   message: 'Expected number'
+                                                     // }]
+```
 
-const V = { } // invalid
+Compiled routines can be inspected with the `.Code()` function.
 
-if(!C.Check(V)) {
-  for(const error of C.Errors(V)) {
-    console.log(error)
-  }
-}
+```typescript
+const C = TypeCompiler.Compile(Type.String())        // const C: TypeCheck<TString>
+
+console.log(C.Code())                                // return function check(value) {
+                                                     //   return (
+                                                     //     (typeof value === 'string')
+                                                     //   )
+                                                     // }
 ```
-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.
+
+### Benchmarks
+
+This project maintains benchmarks that measure TypeBox and AJV compile and validate performance. These benchmarks can be run locally by cloning this repository and running `npm run benchmark`. Results show for AJV version 8.11.0.
+
+#### Validate
+
+This benchmark measures overall validate performance. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/check.ts).
 
 ```typescript
-const C = TypeCompiler.Compile(Type.String())
+┌──────────────────┬────────────┬────────────┬────────────┬────────────────────────┐
+│     (index)      │ Iterations │    Ajv     │  TypeBox   │        Measured        │
+├──────────────────┼────────────┼────────────┼────────────┼────────────────────────┤
+│           Number │  16000000  │ '74ms    ' │ '66ms    ' │ '1.12 x faster       ' │
+│           String │  16000000  │ '277ms   ' │ '154ms   ' │ '1.80 x faster       ' │
+│          Boolean │  16000000  │ '263ms   ' │ '152ms   ' │ '1.73 x faster       ' │
+│             Null │  16000000  │ '275ms   ' │ '153ms   ' │ '1.80 x faster       ' │
+│            RegEx │  16000000  │ '658ms   ' │ '548ms   ' │ '1.20 x faster       ' │
+│          ObjectA │  16000000  │ '453ms   ' │ '319ms   ' │ '1.42 x faster       ' │
+│          ObjectB │  16000000  │ '676ms   ' │ '514ms   ' │ '1.32 x faster       ' │
+│            Tuple │  16000000  │ '320ms   ' │ '193ms   ' │ '1.66 x faster       ' │
+│            Union │  16000000  │ '331ms   ' │ '211ms   ' │ '1.57 x faster       ' │
+│        Recursive │  16000000  │ '6010ms  ' │ '2368ms  ' │ '2.54 x faster       ' │
+│          Vector4 │  16000000  │ '313ms   ' │ '168ms   ' │ '1.86 x faster       ' │
+│          Matrix4 │  16000000  │ '604ms   ' │ '419ms   ' │ '1.44 x faster       ' │
+│   Literal_String │  16000000  │ '281ms   ' │ '154ms   ' │ '1.82 x faster       ' │
+│   Literal_Number │  16000000  │ '268ms   ' │ '150ms   ' │ '1.79 x faster       ' │
+│  Literal_Boolean │  16000000  │ '273ms   ' │ '149ms   ' │ '1.83 x faster       ' │
+│     Array_Number │  16000000  │ '470ms   ' │ '235ms   ' │ '2.00 x faster       ' │
+│     Array_String │  16000000  │ '462ms   ' │ '303ms   ' │ '1.52 x faster       ' │
+│    Array_Boolean │  16000000  │ '527ms   ' │ '352ms   ' │ '1.50 x faster       ' │
+│    Array_ObjectA │  16000000  │ '43852ms ' │ '28042ms ' │ '1.56 x faster       ' │
+│    Array_ObjectB │  16000000  │ '48025ms ' │ '33205ms ' │ '1.45 x faster       ' │
+│      Array_Tuple │  16000000  │ '1424ms  ' │ '1095ms  ' │ '1.30 x faster       ' │
+│    Array_Vector4 │  16000000  │ '1495ms  ' │ '808ms   ' │ '1.85 x faster       ' │
+│    Array_Matrix4 │  16000000  │ '6129ms  ' │ '4969ms  ' │ '1.23 x faster       ' │
+└──────────────────┴────────────┴────────────┴────────────┴────────────────────────┘
+```
 
-console.log(C.Code())
-//
-// outputs:
-//
-// return function check(value) {
-//   return (
-//     (typeof value === 'string')
-//  )
-// }
+#### Compile
+
+This benchmark measures schema compilation time. You can review this benchmark [here](https://github.com/sinclairzx81/typebox/blob/master/benchmark/compile.ts).
+
+```typescript
+┌──────────────────┬────────────┬────────────┬────────────┬────────────────────────┐
+│     (index)      │ Iterations │    Ajv     │  TypeBox   │        Measured        │
+├──────────────────┼────────────┼────────────┼────────────┼────────────────────────┤
+│           Number │    2000    │ '400ms   ' │ '8ms     ' │ '50.00 x faster      ' │
+│           String │    2000    │ '324ms   ' │ '7ms     ' │ '46.29 x faster      ' │
+│          Boolean │    2000    │ '325ms   ' │ '10ms    ' │ '32.50 x faster      ' │
+│             Null │    2000    │ '271ms   ' │ '4ms     ' │ '67.75 x faster      ' │
+│            RegEx │    2000    │ '493ms   ' │ '11ms    ' │ '44.82 x faster      ' │
+│          ObjectA │    2000    │ '2998ms  ' │ '27ms    ' │ '111.04 x faster     ' │
+│          ObjectB │    2000    │ '3058ms  ' │ '28ms    ' │ '109.21 x faster     ' │
+│            Tuple │    2000    │ '1306ms  ' │ '19ms    ' │ '68.74 x faster      ' │
+│            Union │    2000    │ '1450ms  ' │ '18ms    ' │ '80.56 x faster      ' │
+│          Vector4 │    2000    │ '1633ms  ' │ '12ms    ' │ '136.08 x faster     ' │
+│          Matrix4 │    2000    │ '984ms   ' │ '10ms    ' │ '98.40 x faster      ' │
+│   Literal_String │    2000    │ '376ms   ' │ '5ms     ' │ '75.20 x faster      ' │
+│   Literal_Number │    2000    │ '396ms   ' │ '7ms     ' │ '56.57 x faster      ' │
+│  Literal_Boolean │    2000    │ '383ms   ' │ '3ms     ' │ '127.67 x faster     ' │
+│     Array_Number │    2000    │ '748ms   ' │ '6ms     ' │ '124.67 x faster     ' │
+│     Array_String │    2000    │ '774ms   ' │ '5ms     ' │ '154.80 x faster     ' │
+│    Array_Boolean │    2000    │ '814ms   ' │ '8ms     ' │ '101.75 x faster     ' │
+│    Array_ObjectA │    2000    │ '3675ms  ' │ '24ms    ' │ '153.13 x faster     ' │
+│    Array_ObjectB │    2000    │ '4364ms  ' │ '30ms    ' │ '145.47 x faster     ' │
+│      Array_Tuple │    2000    │ '2236ms  ' │ '13ms    ' │ '172.00 x faster     ' │
+│    Array_Vector4 │    2000    │ '1772ms  ' │ '15ms    ' │ '118.13 x faster     ' │
+│    Array_Matrix4 │    2000    │ '1612ms  ' │ '10ms    ' │ '161.20 x faster     ' │
+└──────────────────┴────────────┴────────────┴────────────┴────────────────────────┘
 ```
 
 <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/value/cast.js

@@ -238,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))

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) {
@@ -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;
@@ -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 new Error('ValueCreate: Cannot create Union with zero variants');
+            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 new Error(`ValueCreate: 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]);
         }
@@ -61,19 +70,19 @@ var ValueErrors;
             yield { schema, path, value, message: `Expected integer` };
         }
         if (schema.multipleOf && !(value % schema.multipleOf === 0)) {
-            yield { schema, path, value, message: `Expected number to be a multiple of ${schema.multipleOf}` };
+            yield { schema, path, value, message: `Expected integer to be a multiple of ${schema.multipleOf}` };
         }
         if (schema.exclusiveMinimum && !(value > schema.exclusiveMinimum)) {
-            yield { schema, path, value, message: `Expected number to be greater than ${schema.exclusiveMinimum}` };
+            yield { schema, path, value, message: `Expected integer to be greater than ${schema.exclusiveMinimum}` };
         }
         if (schema.exclusiveMaximum && !(value < schema.exclusiveMaximum)) {
-            yield { schema, path, value, message: `Expected number to be less than ${schema.exclusiveMaximum}` };
+            yield { schema, path, value, message: `Expected integer to be less than ${schema.exclusiveMaximum}` };
         }
         if (schema.minimum && !(value >= schema.minimum)) {
-            yield { schema, path, value, message: `Expected number to be greater or equal to ${schema.minimum}` };
+            yield { schema, path, value, message: `Expected integer to be greater or equal to ${schema.minimum}` };
         }
         if (schema.maximum && !(value <= schema.maximum)) {
-            yield { schema, path, value, message: `Expected number to be less or equal to ${schema.maximum}` };
+            yield { schema, path, value, message: `Expected integer to be less or equal to ${schema.maximum}` };
         }
     }
     function* Literal(schema, references, path, value) {
@@ -172,6 +181,12 @@ var ValueErrors;
         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)) {