@sinclair/typebox 0.31.0 → 0.31.2

package/compiler/compiler.js

@@ -145,6 +145,16 @@ var Identifier;
     Identifier.Encode = Encode;
 })(Identifier || (Identifier = {}));
 // -------------------------------------------------------------------
+// LiteralString
+// -------------------------------------------------------------------
+var LiteralString;
+(function (LiteralString) {
+    function Escape(content) {
+        return content.replace(/'/g, "\\'");
+    }
+    LiteralString.Escape = Escape;
+})(LiteralString || (LiteralString = {}));
+// -------------------------------------------------------------------
 // Errors
 // -------------------------------------------------------------------
 class TypeCompilerUnknownTypeError extends Types.TypeBoxError {
@@ -303,7 +313,7 @@ var TypeCompiler;
             yield `(${value} === ${schema.const})`;
         }
         else {
-            yield `(${value} === '${schema.const}')`;
+            yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
         }
     }
     function* TNever(schema, references, value) {

package/package.json

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

package/readme.md

@@ -58,9 +58,9 @@ type T = Static<typeof T>                            // type T = {
 
 ## Overview
 
-TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript and runtime checked using standard Json Schema validation.
+TypeBox is a runtime type builder that creates Json Schema objects that infer as TypeScript types. The schemas produced by this library are designed to match the static type checking rules of the TypeScript compiler. TypeBox offers a unified type that can be statically checked by TypeScript or runtime checked using standard Json Schema validation.
 
-TypeBox is designed to be a runtime type system based on industry standard specifications for use in distributed systems. It offers serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, a high performance runtime validation compiler, various tools for working with dynamic data and offers detailed structured error reporting.
+TypeBox is built upon industry standard specifications. It offers reflectable, serializable and publishable types as standard, a fully extensible type system capable of supporting multiple schema specifications, includes a high performance validation compiler, offers various tools for working with dynamic data and provides detailed structured error reporting. 
 
 TypeBox can be used as a simple tool to build up complex schemas or integrated into applications to enable high performance runtime validation for data received over the wire.
 
@@ -1169,9 +1169,9 @@ const Z = Value.Cast(T, { x: 1, y: 2, z: 3 })        // const Z = { x: 1, y: 2 }
 Use the Decode function to decode a value from a type, or throw if the value is invalid. The return value will infer as the decoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Decode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Decode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Decode(Type.String(), 42)             // throw
+const B = Value.Decode(Type.String(), 42)             // throw
 ```
 <a name='values-decode'></a>
 
@@ -1180,9 +1180,9 @@ const B = Type.Decode(Type.String(), 42)             // throw
 Use the Encode function to encode a value to a type, or throw if the value is invalid. The return value will infer as the encoded type. This function will run Transform codecs if available.
 
 ```typescript
-const A = Type.Encode(Type.String(), 'hello')        // const A = 'hello'
+const A = Value.Encode(Type.String(), 'hello')        // const A = 'hello'
 
-const B = Type.Encode(Type.String(), 42)             // throw
+const B = Value.Encode(Type.String(), 42)             // throw
 ```
 
 <a name='values-equal'></a>

package/value/transform.js

@@ -88,10 +88,10 @@ var HasTransform;
         return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references);
     }
     function TConstructor(schema, references) {
-        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references));
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
     }
     function TFunction(schema, references) {
-        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema.returns, references));
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
     }
     function TIntersect(schema, references) {
         return Types.TypeGuard.TTransform(schema) || Types.TypeGuard.TTransform(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));