@sinclair/typebox 0.29.0 → 0.29.1

package/package.json

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

package/readme.md

@@ -888,7 +888,7 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
 
 ### Not Types
 
-Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that negated (or not) types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used with intersect types, the Not type can create refined assertion rules for types by leveraging TypeScript's ability to narrow from `unknown` to an intended type through intersection.
+Not types are supported with `Type.Not`. This type represents the JSON Schema `not` keyword and will statically infer as `unknown`. Note that Not types are not supported in TypeScript, but can still be partially expressed by interpreting `not` as the broad type `unknown`. When used in intersections, the Not type can be used to create refined assertion rules for specific types, with the inference derived from TypeScript's ability to narrow from `unknown` to `T` via intersection.
 
 For example, consider a type which is `number` but not `1 | 2 | 3` and where the static type would still technically be a `number`. The following shows a pseudo TypeScript example using `not` followed by the TypeBox implementation.
 
@@ -1473,6 +1473,7 @@ The following is a list of community packages that provide general tooling and f
 | [fetch-typebox](https://github.com/erfanium/fetch-typebox) | Drop-in replacement for fetch that brings easy integration with TypeBox |
 | [schema2typebox](https://github.com/xddq/schema2typebox)  | Creating TypeBox code from JSON schemas |
 | [ts2typebox](https://github.com/xddq/ts2typebox) | Creating TypeBox code from Typescript types |
+| [typebox-client](https://github.com/flodlc/typebox-client) | Type safe http client library for Fastify |
 | [typebox-validators](https://github.com/jtlapp/typebox-validators) | Advanced validators supporting discriminated and heterogeneous unions |
 
 <a name='benchmark'></a>

package/typebox.js

@@ -887,7 +887,7 @@ var TypeExtends;
     // --------------------------------------------------------------------------
     // Not
     // --------------------------------------------------------------------------
-    function ResolveNot(schema) {
+    function UnwrapNot(schema) {
         let [current, depth] = [schema, 0];
         while (true) {
             if (!TypeGuard.TNot(current))
@@ -897,6 +897,16 @@ var TypeExtends;
         }
         return depth % 2 === 0 ? current : exports.Type.Unknown();
     }
+    function Not(left, right) {
+        // TypeScript has no concept of negated types, and attempts to correctly check the negated
+        // type at runtime would put TypeBox at odds with TypeScripts ability to statically infer
+        // the type. Instead we unwrap to either unknown or T and continue evaluating.
+        if (TypeGuard.TNot(left))
+            return Visit(UnwrapNot(left), right);
+        if (TypeGuard.TNot(right))
+            return Visit(left, UnwrapNot(right));
+        throw new Error(`TypeExtends: Invalid fallthrough for Not`);
+    }
     // --------------------------------------------------------------------------
     // Null
     // --------------------------------------------------------------------------
@@ -1182,6 +1192,19 @@ var TypeExtends;
         return TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     // --------------------------------------------------------------------------
+    // TemplateLiteral
+    // --------------------------------------------------------------------------
+    function TemplateLiteral(left, right) {
+        // TemplateLiteral types are resolved to either unions for finite expressions or string
+        // for infinite expressions. Here we call to TemplateLiteralResolver to resolve for
+        // either type and continue evaluating.
+        if (TypeGuard.TTemplateLiteral(left))
+            return Visit(TemplateLiteralResolver.Resolve(left), right);
+        if (TypeGuard.TTemplateLiteral(right))
+            return Visit(left, TemplateLiteralResolver.Resolve(right));
+        throw new Error(`TypeExtends: Invalid fallthrough for TemplateLiteral`);
+    }
+    // --------------------------------------------------------------------------
     // Tuple
     // --------------------------------------------------------------------------
     function TupleRight(left, right) {
@@ -1317,17 +1340,12 @@ var TypeExtends;
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, right) {
-        // Not Unwrap
-        if (TypeGuard.TNot(left))
-            return Visit(ResolveNot(left), right);
-        if (TypeGuard.TNot(right))
-            return Visit(left, ResolveNot(right));
-        // Template Literal Union Unwrap
-        if (TypeGuard.TTemplateLiteral(left))
-            return Visit(TemplateLiteralResolver.Resolve(left), right);
-        if (TypeGuard.TTemplateLiteral(right))
-            return Visit(left, TemplateLiteralResolver.Resolve(right));
-        // Standard Extends
+        // Resolvable Types
+        if (TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right))
+            return TemplateLiteral(left, right);
+        if (TypeGuard.TNot(left) || TypeGuard.TNot(right))
+            return Not(left, right);
+        // Standard Types
         if (TypeGuard.TAny(left))
             return Any(left, right);
         if (TypeGuard.TArray(left))