@sinclair/typebox 0.28.15 → 0.28.16

package/compiler/compiler.js

@@ -199,14 +199,15 @@ var TypeCompiler;
         yield 'true';
     }
     function* Array(schema, references, value) {
-        const expression = CreateExpression(schema.items, references, 'value');
+        yield `Array.isArray(${value})`;
         if (IsNumber(schema.minItems))
             yield `${value}.length >= ${schema.minItems}`;
         if (IsNumber(schema.maxItems))
             yield `${value}.length <= ${schema.maxItems}`;
         if (schema.uniqueItems === true)
             yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
-        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
+        const expression = CreateExpression(schema.items, references, 'value');
+        yield `${value}.every(value => ${expression})`;
     }
     function* BigInt(schema, references, value) {
         yield `(typeof ${value} === 'bigint')`;
@@ -358,9 +359,9 @@ var TypeCompiler;
         if (index === -1)
             throw new TypeCompilerDereferenceError(schema);
         const target = references[index];
-        // Reference: If we have seen this reference before we can just yield and return
-        // the function call. If this isn't the case we defer to visit to generate and
-        // set the function for subsequent passes. Consider for refactor.
+        // Reference: If we have seen this reference before we can just yield and
+        // return the function call. If this isn't the case we defer to visit to
+        // generate and set the function for subsequent passes.
         if (state_local_function_names.has(schema.$ref))
             return yield `${CreateFunctionName(schema.$ref)}(${value})`;
         yield* Visit(target, references, value);
@@ -392,7 +393,7 @@ var TypeCompiler;
         yield `${func}(${value})`;
     }
     function* Tuple(schema, references, value) {
-        yield `(Array.isArray(${value}))`;
+        yield `Array.isArray(${value})`;
         if (schema.items === undefined)
             return yield `${value}.length === 0`;
         yield `(${value}.length === ${schema.maxItems})`;
@@ -429,10 +430,13 @@ var TypeCompiler;
     function* Visit(schema, references, value, root = false) {
         const references_ = IsString(schema.$id) ? [...references, schema] : references;
         const schema_ = schema;
-        // Rule: Types with identifiers are hoisted into their own functions. The following will generate a function for the schema
-        // and yield the call to that function. This call is only made if NOT the root type which allows the generated function to
-        // yield its expression. The root argument is only true when making calls via CreateFunction(). Note there is potential to
-        // omit the root argument and conditional by refactoring the logic below. Consider for review.
+        // Rule: Types with identifiers are hoisted into their own functions.
+        // The following will generate a function for the schema and yield the
+        // call to that function. This call is only made if NOT the root type
+        // which allows the generated function to yield its expression. The
+        // root argument is only true when making calls via CreateFunction().
+        // Note there is potential to omit the root argument and conditional
+        // by refactoring the logic below. Consider for review.
         if (IsString(schema.$id)) {
             const name = CreateFunctionName(schema.$id);
             if (!state_local_function_names.has(schema.$id)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.15",
+  "version": "0.28.16",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -483,7 +483,7 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ ])                             │                             │   ],                           │
 │ const T = Type.Tuple([         │                             │   additionalItems: false,      │
 |   ...Type.Rest(A),             │                             │   minItems: 4,                 │
-|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+|   ...Type.Rest(B)              │                             │   maxItems: 4                  │
 │ ])                             │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
@@ -870,7 +870,7 @@ const T = Type.Object({                              // const T = {
   z: Type.Boolean()                                  //   properties: {
 })                                                   //     x: { type: 'number' },
                                                      //     y: { type: 'string' },
-                                                     //     z: { type: 'string' },
+                                                     //     z: { type: 'string' }
                                                      //   }
                                                      // }
 
@@ -896,7 +896,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Rest Types
 
-Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatination as well as for variadic functions.
+Rest parameters are supported with `Type.Rest`. This function is used to extract interior type elements from tuples which enables them to compose with the JavaScript spread operator `...`. This type can be used for tuple concatenation as well as for variadic functions.
 
 ```typescript
 // TypeScript
@@ -908,14 +908,14 @@ type C = [...T, number]                              // type C = [number, number
 type F = (...param: C) => void                       // type F = (
                                                      //   param0: number,
                                                      //   param1: number,
-                                                     //   param2: number,
+                                                     //   param2: number
                                                      // ) => void
 
 // TypeBox
 
 const T = Type.Tuple([                               // const T: TTuple<[
   Type.Number(),                                     //   TNumber,
-  Type.Number()                                      //   TNumber,
+  Type.Number()                                      //   TNumber
 ])                                                   // ]>
 
 const C = Type.Tuple([                               // const C: TTuple<[
@@ -1335,7 +1335,7 @@ console.log(C.Code())                                // return function check(va
 
 ## TypeSystem
 
-The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion polices. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
+The TypeBox TypeSystem module provides functionality to define types above and beyond the Standard and Extended type sets as well as control various assertion policies. Configurations made to the TypeSystem module are observed by both `TypeCompiler` and `Value` modules.
 
 The TypeSystem module is provided as an optional import.