@sinclair/typebox 0.28.9 → 0.28.11

package/compiler/compiler.js

@@ -257,7 +257,7 @@ var TypeCompiler;
         }
         else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
             const keyCheck = PushLocal(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
-            const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, 'value[key]')})`;
+            const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
             yield `${check1} && ${check2}`;
         }
         else {
@@ -326,7 +326,7 @@ var TypeCompiler;
             }
         }
         if (typeof schema.additionalProperties === 'object') {
-            const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
+            const expression = CreateExpression(schema.additionalProperties, references, `${value}[key]`);
             const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
             yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
         }

package/package.json

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

package/readme.md

@@ -11,9 +11,8 @@
 
 [![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)
-[![Install Size](https://packagephobia.com/badge?p=@sinclair/typebox)](https://packagephobia.com/result?p=@sinclair/typebox)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 </div>
 
@@ -109,6 +108,7 @@ License MIT
   - [Types](#typesystem-types)
   - [Formats](#typesystem-formats)
   - [Policies](#typesystem-policies)
+- [Workbench](#workbench)
 - [Benchmark](#benchmark)
   - [Compile](#benchmark-compile)
   - [Validate](#benchmark-validate)
@@ -1346,26 +1346,31 @@ import { TypeSystem } from '@sinclair/typebox/system'
 
 ### Types
 
-Use the `Type(...)` function to create a custom type. This function will return a type factory function that can be used to construct the type. The following creates a Point type.
+Use the `Type(...)` function to create custom types. This function lets you specify custom value assertion logic and will return a type factory function which is used to instance the type. This function accepts two generic arguments, the first is the inference type, the second is options used to constrain the type. The following creates a Vector type.
 
 ```typescript
-type PointOptions = { }                              // The Type Options
+type VectorOptions = { abs: boolean }       
 
-type PointType = { x: number, y: number }            // The Static<T> Type
+type Vector = { x: number, y: number }
 
-const Point = TypeSystem.Type<PointType, PointOptions>('Point', (options, value) => {
+const Vector = TypeSystem.Type<Vector, VectorOptions>('Vector', (options, value) => {
   return (
     typeof value === 'object' && value !== null &&
-    typeof value.x === 'number' && 
-    typeof value.y === 'number'
+    'x' in value && typeof value.x === 'number' && 
+    'y' in value && typeof value.y === 'number' && 
+    (options.abs ? (value.x === Math.abs(value.x) && value.y === Math.abs(value.y)) : true)
   )
 })
 
-const T = Point()
+const T = Vector({ abs: true })
+
+type T = Static<typeof T>                            // type T = Vector
+
+const R1 = Value.Check(T, { x: 1, y: 1 })            // const R1 = true
 
-type T = Static<typeof T>                             // type T = { x: number, y: number }
+const R2 = Value.Check(T, { x: 1, y: '1' })          // const R2 = false
 
-const R = Value.Check(T, { x: 1, y: 2 })              // const R = true
+const R3 = Value.Check(T, { x: 1, y: -1 })           // const R3 = false
 ```
 
 <a name='typesystem-formats'></a>
@@ -1410,6 +1415,20 @@ TypeSystem.AllowArrayObjects = true
 TypeSystem.AllowNaN = true                      
 ```
 
+<a name='workbench'></a>
+
+## Workbench
+
+TypeBox offers a web based code generation tool that can be used to create TypeBox types from TypeScript type definitions. This tool is written to prototype new TypeBox features, but can be used to rapidly convert TypeScript type definitions in to TypeBox types as well as raw JSON Schema.
+
+[Workbench Link Here](https://sinclairzx81.github.io/typebox-workbench/)
+
+<div align='center'>
+	
+<a href="https://sinclairzx81.github.io/typebox-workbench/"><img src="https://github.com/sinclairzx81/typebox/blob/master/workbench.png?raw=true" /></a>
+
+</div>
+
 <a name='benchmark'></a>
 
 ## Benchmark

package/typebox.js

@@ -621,6 +621,14 @@ var ExtendsUndefined;
     function Check(schema) {
         if (schema[exports.Kind] === 'Undefined')
             return true;
+        if (schema[exports.Kind] === 'Not') {
+            const not = schema;
+            return Check(not.allOf[1]);
+        }
+        if (schema[exports.Kind] === 'Intersect') {
+            const intersect = schema;
+            return intersect.allOf.every((schema) => Check(schema));
+        }
         if (schema[exports.Kind] === 'Union') {
             const union = schema;
             return union.anyOf.some((schema) => Check(schema));

package/value/check.js

@@ -254,8 +254,8 @@ var ValueCheck;
                 if (!Visit(property, references, value[knownKey])) {
                     return false;
                 }
-                if (Types.ExtendsUndefined.Check(property)) {
-                    return knownKey in value;
+                if (Types.ExtendsUndefined.Check(property) && !(knownKey in value)) {
+                    return false;
                 }
             }
             else {