@sinclair/typebox 0.28.20 → 0.29.1

package/compiler/compiler.js

@@ -284,9 +284,8 @@ var TypeCompiler;
         yield `false`;
     }
     function* Not(schema, references, value) {
-        const left = CreateExpression(schema.allOf[0].not, references, value);
-        const right = CreateExpression(schema.allOf[1], references, value);
-        yield `!${left} && ${right}`;
+        const expression = CreateExpression(schema.not, references, value);
+        yield `(!${expression})`;
     }
     function* Null(schema, references, value) {
         yield `(${value} === null)`;

package/errors/errors.js

@@ -313,10 +313,9 @@ var ValueErrors;
         yield { type: ValueErrorType.Never, schema, path, value, message: `Value cannot be validated` };
     }
     function* Not(schema, references, path, value) {
-        if (Visit(schema.allOf[0].not, references, path, value).next().done === true) {
+        if (Visit(schema.not, references, path, value).next().done === true) {
             yield { type: ValueErrorType.Not, schema, path, value, message: `Value should not validate` };
         }
-        yield* Visit(schema.allOf[1], references, path, value);
     }
     function* Null(schema, references, path, value) {
         if (!(value === null)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.20",
+  "version": "0.29.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",
@@ -42,6 +42,6 @@
     "chai": "^4.3.6",
     "mocha": "^9.2.2",
     "prettier": "^2.7.1",
-    "typescript": "^5.1.3"
+    "typescript": "^5.1.6"
   }
 }

package/readme.md

@@ -84,6 +84,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template Literal](#types-template-literal)
   - [Indexed](#types-indexed)
+  - [Not](#types-not)
   - [Rest](#types-rest)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
@@ -353,20 +354,11 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Not(            | type T = string             │ const T = {                    │
-|   Type.Union([                 │                             │   allOf: [{                    │
-│     Type.Literal('x'),         │                             │     not: {                     │
-│     Type.Literal('y'),         │                             │       anyOf: [                 │
-│     Type.Literal('z')          │                             │         { const: 'x' },        │
-│   ]),                          │                             │         { const: 'y' },        │
-│   Type.String()                │                             │         { const: 'z' }         │
-│ )                              │                             │       ]                        │
-│                                │                             │     }                          │
-│                                │                             │   }, {                         │
-│                                │                             │     type: 'string'             │
-│                                │                             │   }]                           │
+│ const T = Type.Not(            | type T = unknown            │ const T = {                    │
+│   Type.String()                │                             │   not: {                       │
+│ )                              │                             │     type: 'string'             │
+│                                │                             │   }                            │
 │                                │                             │ }                              │
-│                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Extends(        │ type T =                    │ const T = {                    │
 │   Type.String(),               │  string extends number      │   const: false,                │
@@ -650,7 +642,7 @@ const T = Type.String({                              // const T = {
 })                                                   //   format: 'email'
                                                      // }
 
-// Mumber must be a multiple of 2
+// Number must be a multiple of 2
 const T = Type.Number({                              // const T = {
   multipleOf: 2                                      //  type: 'number',
 })                                                   //  multipleOf: 2
@@ -892,6 +884,49 @@ const C = Type.Index(T, Type.KeyOf(T))               // const C = {
                                                      // }
 ```
 
+<a name='types-not'></a>
+
+### 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 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.
+
+```typescript
+// Pseudo TypeScript
+
+type T = number & not (1 | 2 | 3)                    // allow all numbers except 1, 2, 3
+
+// TypeBox
+
+const T = Type.Intersect([                           // const T = {
+  Type.Number(),                                     //   allOf: [
+  Type.Not(Type.Union([                              //     { type: "number" },
+    Type.Literal(1),                                 //     {
+    Type.Literal(2),                                 //       not: {
+    Type.Literal(3)                                  //         anyOf: [
+  ]))                                                //           { const: 1, type: "number" },
+])                                                   //           { const: 2, type: "number" },
+                                                     //           { const: 3, type: "number" }
+                                                     //         ]
+                                                     //       }
+                                                     //     }
+                                                     //   ]
+                                                     // }
+
+type T = Static<typeof T>                            // evaluates as:
+                                                     //
+                                                     // type T = (number & (not (1 | 2 | 3)))
+                                                     // type T = (number & (unknown))
+                                                     // type T = (number) 
+```
+
+The Not type can be used with constraints to define schematics for types that would otherwise be difficult to express.
+```typescript
+const Even = Type.Number({ multipleOf: 2 })
+
+const Odd = Type.Intersect([Type.Number(), Type.Not(Even)])          
+```
 <a name='types-rest'></a>
 
 ### Rest Types
@@ -1420,29 +1455,26 @@ TypeSystem.AllowNaN = true
 
 ## Workbench
 
-TypeBox offers a small web based code generation tool that can be used to convert TypeScript types into TypeBox type definitions as well as a variety of other formats.
+TypeBox offers a web based code generation tool that can be used to convert TypeScript types into TypeBox types as well as a variety of other runtime type representations.
 
 [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='ecosystem'></a>
 
 ## Ecosystem
 
-The following is a list of community packages that provide general tooling and framework support for TypeBox.
+The following is a list of community packages that provide general tooling and framework integration support for TypeBox.
 
 | Package   |  Description |
 | ------------- | ------------- |
 | [elysia](https://github.com/elysiajs/elysia) | Fast and friendly Bun web framework |
 | [fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox) | Fastify TypeBox integration with the Fastify Type Provider |
+| [feathersjs](https://github.com/feathersjs/feathers) | The API and real-time application framework |
 | [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 |
+| [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.d.ts

@@ -169,14 +169,7 @@ export type TIndexType<T extends TSchema, K extends Key> = T extends TRecursive<
 ];
 export type TIndexRestMany<T extends TSchema, K extends Key[]> = K extends [infer L, ...infer R] ? [TIndexType<T, Assert<L, Key>>, ...TIndexRestMany<T, Assert<R, Key[]>>] : [
 ];
-export type TIndexReduce<T extends TSchema, K extends Key[]> = T extends TRecursive<infer S> ? TIndexReduce<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : TNever;
-export type TIndex<T extends TSchema, K extends TSchema> = [
-    T,
-    K
-] extends [TTuple, TNumber] ? UnionType<Assert<T['items'], TSchema[]>> : [
-    T,
-    K
-] extends [TArray, TNumber] ? AssertType<T['items']> : K extends TTemplateLiteral ? TIndexReduce<T, TTemplateLiteralKeyRest<K>> : K extends TUnion<TLiteral<Key>[]> ? TIndexReduce<T, TUnionLiteralKeyRest<K>> : K extends TLiteral<Key> ? TIndexReduce<T, [K['const']]> : TNever;
+export type TIndex<T extends TSchema, K extends Key[]> = T extends TRecursive<infer S> ? TIndex<S, K> : T extends TIntersect ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TUnion ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TObject ? UnionType<Flat<TIndexRestMany<T, K>>> : T extends TTuple ? UnionType<Flat<TIndexRestMany<T, K>>> : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -214,12 +207,10 @@ export interface TNever extends TSchema {
     static: never;
     not: {};
 }
-export interface TNot<Not extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+export interface TNot<T extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Not';
-    static: Static<T>;
-    allOf: [{
-        not: Not;
-    }, T];
+    static: T extends TNot<infer U> ? Static<U> : unknown;
+    not: T;
 }
 export interface TNull extends TSchema {
     [Kind]: 'Null';
@@ -662,9 +653,19 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Extracts from the left type any type that is assignable to the right */
     Extract<L extends TSchema, R extends TSchema>(left: L, right: R, options?: SchemaOptions): TExtract<L, R>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexReduce<T, Assert<K, Key[]>>;
+    Index<T extends TTuple, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TIndex<T, K>;
+    Index<T extends TArray, K extends TNumber>(schema: T, keys: K, options?: SchemaOptions): AssertType<T['items']>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyRest<K>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndex<T, Assert<K, Key[]>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TUnionLiteralKeyRest<K>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TSchema, K extends TSchema>(schema: T, key: K, options?: SchemaOptions): TSchema;
     /** `[Standard]` Creates an Integer type */
     Integer(options?: NumericOptions<number>): TInteger;
     /** `[Standard]` Creates a Intersect type */
@@ -678,8 +679,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
     /** `[Standard]` Creates a Never type */
     Never(options?: SchemaOptions): TNever;
-    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-    Not<N extends TSchema, T extends TSchema>(not: N, schema: T, options?: SchemaOptions): TNot<N, T>;
+    /** `[Standard]` Creates a Not type */
+    Not<T extends TSchema>(not: T, options?: SchemaOptions): TNot<T>;
     /** `[Standard]` Creates a Null type */
     Null(options?: SchemaOptions): TNull;
     /** `[Standard]` Creates a Number type */

package/typebox.js

@@ -339,11 +339,7 @@ var TypeGuard;
         // prettier-ignore
         return (TKind(schema) &&
             schema[exports.Kind] === 'Not' &&
-            IsArray(schema.allOf) &&
-            schema.allOf.length === 2 &&
-            IsObject(schema.allOf[0]) &&
-            TSchema(schema.allOf[0].not) &&
-            TSchema(schema.allOf[1]));
+            TSchema(schema.not));
     }
     TypeGuard.TNot = TNot;
     /** Returns true if the given schema is TNull */
@@ -622,8 +618,7 @@ var ExtendsUndefined;
         if (schema[exports.Kind] === 'Undefined')
             return true;
         if (schema[exports.Kind] === 'Not') {
-            const not = schema;
-            return Check(not.allOf[1]);
+            return !Check(schema.not);
         }
         if (schema[exports.Kind] === 'Intersect') {
             const intersect = schema;
@@ -890,6 +885,29 @@ var TypeExtends;
         return TypeExtendsResult.True;
     }
     // --------------------------------------------------------------------------
+    // Not
+    // --------------------------------------------------------------------------
+    function UnwrapNot(schema) {
+        let [current, depth] = [schema, 0];
+        while (true) {
+            if (!TypeGuard.TNot(current))
+                break;
+            current = current.not;
+            depth += 1;
+        }
+        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
     // --------------------------------------------------------------------------
     function Null(left, right) {
@@ -1174,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) {
@@ -1309,12 +1340,12 @@ var TypeExtends;
         return TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
     }
     function Visit(left, 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))
@@ -2077,9 +2108,9 @@ class StandardTypeBuilder extends TypeBuilder {
     Never(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Never', not: {} });
     }
-    /** `[Standard]` Creates a Not type. The first argument is the disallowed type, the second is the allowed. */
-    Not(not, schema, options) {
-        return this.Create({ ...options, [exports.Kind]: 'Not', allOf: [{ not: TypeClone.Clone(not, {}) }, TypeClone.Clone(schema, {})] });
+    /** `[Standard]` Creates a Not type */
+    Not(not, options) {
+        return this.Create({ ...options, [exports.Kind]: 'Not', not });
     }
     /** `[Standard]` Creates a Null type */
     Null(options = {}) {

package/value/cast.js

@@ -201,7 +201,7 @@ var ValueCast;
         throw new ValueCastNeverTypeError(schema);
     }
     function Not(schema, references, value) {
-        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema.allOf[1], references);
+        return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);
     }
     function Null(schema, references, value) {
         return check_1.ValueCheck.Check(schema, references, value) ? value : create_1.ValueCreate.Create(schema, references);

package/value/check.js

@@ -217,7 +217,7 @@ var ValueCheck;
         return false;
     }
     function Not(schema, references, value) {
-        return !Visit(schema.allOf[0].not, references, value) && Visit(schema.allOf[1], references, value);
+        return !Visit(schema.not, references, value);
     }
     function Null(schema, references, value) {
         return value === null;

package/value/create.d.ts

@@ -7,6 +7,10 @@ export declare class ValueCreateNeverTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);
 }
+export declare class ValueCreateNotTypeError extends Error {
+    readonly schema: Types.TSchema;
+    constructor(schema: Types.TSchema);
+}
 export declare class ValueCreateIntersectTypeError extends Error {
     readonly schema: Types.TSchema;
     constructor(schema: Types.TSchema);

package/value/create.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueCreate = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
+exports.ValueCreate = exports.ValueCreateRecursiveInstantiationError = exports.ValueCreateDereferenceError = exports.ValueCreateTempateLiteralTypeError = exports.ValueCreateIntersectTypeError = exports.ValueCreateNotTypeError = exports.ValueCreateNeverTypeError = exports.ValueCreateUnknownTypeError = void 0;
 const Types = require("../typebox");
 const check_1 = require("./check");
 // --------------------------------------------------------------------------
@@ -47,6 +47,13 @@ class ValueCreateNeverTypeError extends Error {
     }
 }
 exports.ValueCreateNeverTypeError = ValueCreateNeverTypeError;
+class ValueCreateNotTypeError extends Error {
+    constructor(schema) {
+        super('ValueCreate: Not types must have a default value');
+        this.schema = schema;
+    }
+}
+exports.ValueCreateNotTypeError = ValueCreateNotTypeError;
 class ValueCreateIntersectTypeError extends Error {
     constructor(schema) {
         super('ValueCreate: Intersect produced invalid value. Consider using a default value.');
@@ -215,7 +222,7 @@ var ValueCreate;
             return schema.default;
         }
         else {
-            return Visit(schema.allOf[1], references);
+            throw new ValueCreateNotTypeError(schema);
         }
     }
     function Null(schema, references) {