@sinclair/typebox 0.24.26 → 0.24.29

package/guard/guard.js

@@ -27,8 +27,15 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeGuard = void 0;
+exports.TypeGuard = exports.TypeGuardInvalidTypeError = void 0;
 const Types = require("../typebox");
+class TypeGuardInvalidTypeError extends Error {
+    constructor(schema) {
+        super('TypeGuard: Invalid type');
+        this.schema = schema;
+    }
+}
+exports.TypeGuardInvalidTypeError = TypeGuardInvalidTypeError;
 /** TypeGuard tests that values conform to a known TypeBox type specification */
 var TypeGuard;
 (function (TypeGuard) {
@@ -47,7 +54,7 @@ var TypeGuard;
             return false;
         }
     }
-    function IsValidPropertyKey(value) {
+    function IsControlCharacterFree(value) {
         if (typeof value !== 'string')
             return false;
         for (let i = 0; i < value.length; i++) {
@@ -77,26 +84,36 @@ var TypeGuard;
         return value === undefined || (value !== undefined && IsString(value));
     }
     function IsOptionalPattern(value) {
-        return value === undefined || (value !== undefined && IsString(value) && IsPattern(value));
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
+    }
+    function IsOptionalFormat(value) {
+        return value === undefined || (value !== undefined && IsString(value) && IsControlCharacterFree(value));
     }
     /** Returns true if the given schema is TAny */
     function TAny(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Any';
+        return IsObject(schema) && schema[Types.Kind] === 'Any' && IsOptionalString(schema.$id);
     }
     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) && IsOptionalBoolean(schema.uniqueItems);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Array' &&
+            schema.type === 'array' &&
+            IsOptionalString(schema.$id) &&
+            TSchema(schema.items) &&
+            IsOptionalNumber(schema.minItems) &&
+            IsOptionalNumber(schema.maxItems) &&
+            IsOptionalBoolean(schema.uniqueItems));
     }
     TypeGuard.TArray = TArray;
     /** Returns true if the given schema is TBoolean */
     function TBoolean(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean';
+        return IsObject(schema) && schema[Types.Kind] === 'Boolean' && schema.type === 'boolean' && IsOptionalString(schema.$id);
     }
     TypeGuard.TBoolean = TBoolean;
     /** Returns true if the given schema is TConstructor */
     function TConstructor(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Constructor' && schema.type === 'constructor' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -108,7 +125,7 @@ var TypeGuard;
     TypeGuard.TConstructor = TConstructor;
     /** Returns true if the given schema is TFunction */
     function TFunction(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsArray(schema.parameters) && TSchema(schema.returns))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Function' && schema.type === 'function' && IsOptionalString(schema.$id) && IsArray(schema.parameters) && TSchema(schema.returns))) {
             return false;
         }
         for (const parameter of schema.parameters) {
@@ -123,6 +140,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Integer' &&
             schema.type === 'integer' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -132,12 +150,12 @@ var TypeGuard;
     TypeGuard.TInteger = TInteger;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Literal' && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
+        return IsObject(schema) && schema[Types.Kind] === 'Literal' && IsOptionalString(schema.$id) && (IsString(schema.const) || IsNumber(schema.const) || IsBoolean(schema.const));
     }
     TypeGuard.TLiteral = TLiteral;
     /** Returns true if the given schema is TNull */
     function TNull(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Null' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TNull = TNull;
     /** Returns true if the given schema is TNumber */
@@ -145,6 +163,7 @@ var TypeGuard;
         return (IsObject(schema) &&
             schema[Types.Kind] === 'Number' &&
             schema.type === 'number' &&
+            IsOptionalString(schema.$id) &&
             IsOptionalNumber(schema.multipleOf) &&
             IsOptionalNumber(schema.minimum) &&
             IsOptionalNumber(schema.maximum) &&
@@ -157,6 +176,7 @@ var TypeGuard;
         if (!(IsObject(schema) &&
             schema[Types.Kind] === 'Object' &&
             schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
             IsObject(schema.properties) &&
             IsOptionalBoolean(schema.additionalProperties) &&
             IsOptionalNumber(schema.minProperties) &&
@@ -164,7 +184,7 @@ var TypeGuard;
             return false;
         }
         for (const [key, value] of Object.entries(schema.properties)) {
-            if (!IsValidPropertyKey(key))
+            if (!IsControlCharacterFree(key))
                 return false;
             if (!TSchema(value))
                 return false;
@@ -174,12 +194,12 @@ var TypeGuard;
     TypeGuard.TObject = TObject;
     /** Returns true if the given schema is TPromise */
     function TPromise(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && TSchema(schema.item);
+        return IsObject(schema) && schema[Types.Kind] === 'Promise' && schema.type === 'promise' && IsOptionalString(schema.$id) && TSchema(schema.item);
     }
     TypeGuard.TPromise = TPromise;
     /** Returns true if the given schema is TRecord */
     function TRecord(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Record' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.additionalProperties === false && IsObject(schema.patternProperties))) {
             return false;
         }
         const keys = Object.keys(schema.patternProperties);
@@ -197,22 +217,29 @@ var TypeGuard;
     TypeGuard.TRecord = TRecord;
     /** Returns true if the given schema is TSelf */
     function TSelf(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Self' && IsOptionalString(schema.$id) && IsString(schema.$ref);
     }
     TypeGuard.TSelf = TSelf;
     /** Returns true if the given schema is TRef */
     function TRef(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsString(schema.$ref);
+        return IsObject(schema) && schema[Types.Kind] === 'Ref' && IsOptionalString(schema.$id) && IsString(schema.$ref);
     }
     TypeGuard.TRef = TRef;
     /** Returns true if the given schema is TString */
     function TString(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'String' && schema.type === 'string' && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalString(schema.format);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'String' &&
+            schema.type === 'string' &&
+            IsOptionalString(schema.$id) &&
+            IsOptionalNumber(schema.minLength) &&
+            IsOptionalNumber(schema.maxLength) &&
+            IsOptionalPattern(schema.pattern) &&
+            IsOptionalFormat(schema.format));
     }
     TypeGuard.TString = TString;
     /** Returns true if the given schema is TTuple */
     function TTuple(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Tuple' && schema.type === 'array' && IsOptionalString(schema.$id) && IsNumber(schema.minItems) && IsNumber(schema.maxItems) && schema.minItems === schema.maxItems)) {
             return false;
         }
         if (schema.items === undefined && schema.additionalItems === undefined && schema.minItems === 0) {
@@ -230,12 +257,12 @@ var TypeGuard;
     TypeGuard.TTuple = TTuple;
     /** Returns true if the given schema is TUndefined */
     function TUndefined(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && schema.specialized === 'Undefined';
+        return IsObject(schema) && schema[Types.Kind] === 'Undefined' && schema.type === 'object' && IsOptionalString(schema.$id) && schema.specialized === 'Undefined';
     }
     TypeGuard.TUndefined = TUndefined;
     /** Returns true if the given schema is TUnion */
     function TUnion(schema) {
-        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf))) {
+        if (!(IsObject(schema) && schema[Types.Kind] === 'Union' && IsArray(schema.anyOf) && IsOptionalString(schema.$id))) {
             return false;
         }
         for (const inner of schema.anyOf) {
@@ -247,17 +274,23 @@ var TypeGuard;
     TypeGuard.TUnion = TUnion;
     /** Returns true if the given schema is TUint8Array */
     function TUint8Array(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Uint8Array' && schema.type === 'object' && schema.specialized === 'Uint8Array' && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+        return (IsObject(schema) &&
+            schema[Types.Kind] === 'Uint8Array' &&
+            schema.type === 'object' &&
+            IsOptionalString(schema.$id) &&
+            schema.specialized === 'Uint8Array' &&
+            IsOptionalNumber(schema.minByteLength) &&
+            IsOptionalNumber(schema.maxByteLength));
     }
     TypeGuard.TUint8Array = TUint8Array;
     /** Returns true if the given schema is TUnknown */
     function TUnknown(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Unknown';
+        return IsObject(schema) && schema[Types.Kind] === 'Unknown' && IsOptionalString(schema.$id);
     }
     TypeGuard.TUnknown = TUnknown;
     /** Returns true if the given schema is TVoid */
     function TVoid(schema) {
-        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null';
+        return IsObject(schema) && schema[Types.Kind] === 'Void' && schema.type === 'null' && IsOptionalString(schema.$id);
     }
     TypeGuard.TVoid = TVoid;
     /** Returns true if the given schema is TSchema */
@@ -285,4 +318,14 @@ var TypeGuard;
             TVoid(schema));
     }
     TypeGuard.TSchema = TSchema;
+    /** Asserts if this schema and associated references are valid. */
+    function Assert(schema, references = []) {
+        if (!TSchema(schema))
+            throw new TypeGuardInvalidTypeError(schema);
+        for (const schema of references) {
+            if (!TSchema(schema))
+                throw new TypeGuardInvalidTypeError(schema);
+        }
+    }
+    TypeGuard.Assert = Assert;
 })(TypeGuard = exports.TypeGuard || (exports.TypeGuard = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.24.26",
+  "version": "0.24.29",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -26,15 +26,15 @@
     "publish": "hammer task publish"
   },
   "devDependencies": {
-    "@sinclair/hammer": "^0.16.3",
-    "@types/chai": "^4.3.0",
-    "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.12",
+    "@sinclair/hammer": "^0.17.1",
+    "@types/chai": "^4.3.3",
+    "@types/mocha": "^9.1.1",
+    "@types/node": "^18.7.13",
     "ajv": "^8.11.0",
     "ajv-formats": "^2.1.1",
-    "chai": "^4.3.5",
-    "mocha": "^9.2.0",
+    "chai": "^4.3.6",
+    "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^4.7.4"
+    "typescript": "^4.8.2"
   }
 }