@sinclair/typebox 0.24.25 → 0.24.26

package/compiler/compiler.js

@@ -71,16 +71,7 @@ var Property;
     function Alpha(code) {
         return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
     }
-    function AssertEscapeCharacters(propertyName) {
-        for (let i = 0; i < propertyName.length; i++) {
-            const code = propertyName.charCodeAt(i);
-            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-                throw Error('Property: Invalid escape character found in property key');
-            }
-        }
-    }
     function Check(propertyName) {
-        AssertEscapeCharacters(propertyName);
         if (propertyName.length === 0)
             return false;
         {
@@ -132,7 +123,7 @@ var TypeCompiler;
         yield `(typeof ${value} === 'boolean')`;
     }
     function* Constructor(schema, value) {
-        yield* Visit(schema.returns, value);
+        yield* Visit(schema.returns, `${value}.prototype`);
     }
     function* Function(schema, value) {
         yield `(typeof ${value} === 'function')`;

package/errors/errors.js

@@ -110,7 +110,7 @@ var ValueErrors;
         }
     }
     function* Constructor(schema, references, path, value) {
-        yield* Visit(schema.returns, references, path, value);
+        yield* Visit(schema.returns, references, path, value.prototype);
     }
     function* Function(schema, references, path, value) {
         if (!(typeof value === 'function')) {

package/guard/guard.js

@@ -47,6 +47,17 @@ var TypeGuard;
             return false;
         }
     }
+    function IsValidPropertyKey(value) {
+        if (typeof value !== 'string')
+            return false;
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
+                return false;
+            }
+        }
+        return true;
+    }
     function IsString(value) {
         return typeof value === 'string';
     }
@@ -66,7 +77,7 @@ var TypeGuard;
         return value === undefined || (value !== undefined && IsString(value));
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsPattern(value));
+        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
@@ -75,7 +86,7 @@ var TypeGuard;
     TypeGuard.TAny = TAny;
     /** Returns true if the given schema is TArray */
     function TArray(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Array' && schema.type === 'array' && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems);
+        return IsObject(schema) && schema[Types.Kind] === 'Array' && schema.type === 'array' && TSchema(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems);
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
@@ -152,8 +163,10 @@ var TypeGuard;
             IsOptionalNumber(schema.maxProperties))) {
             return false;
         }
-        for (const property of Object.values(schema.properties)) {
-            if (!TSchema(property))
+        for (const [key, value] of Object.entries(schema.properties)) {
+            if (!IsValidPropertyKey(key))
+                return false;
+            if (!TSchema(value))
                 return false;
         }
         return true;
@@ -166,7 +179,7 @@ var TypeGuard;
     TypeGuard.TPromise = TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsObject(schema.patternProperties))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);

package/package.json

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

package/value/check.js

@@ -60,7 +60,7 @@ var ValueCheck;
         return typeof value === 'boolean';
     }
     function Constructor(schema, references, value) {
-        return Visit(schema.returns, references, value);
+        return Visit(schema.returns, references, value.prototype);
     }
     function Function(schema, references, value) {
         return typeof value === 'function';