@sinclair/typebox 0.31.7 → 0.31.9

package/package.json

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

package/readme.md

@@ -58,11 +58,11 @@ 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 or 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 asserted using standard Json Schema validation.
 
-TypeBox types are designed to express industry standard schematics as TypeScript types. All types are runtime reflectable, serializable and publishable by default. It includes an extensible type system able to represent type safe schematics for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers detailed structured error reporting. 
+TypeBox uses industry standard schematics for runtime type representation; enabling types to be reflected, serialized and published directly. Its type system is fully extensible and able to support type representation for multiple schema specifications. It also provides a high performance validation compiler, various tools for working with dynamic data and offers 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.
+TypeBox can be used as a simple tool to build up complex schemas or integrated into applications and frameworks to enable high performance runtime type checking for data received over the wire.
 
 License MIT
 

package/typebox.d.ts

@@ -72,7 +72,7 @@ export interface TSchema extends SchemaOptions, TKind {
     params: unknown[];
     static: unknown;
 }
-export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;
 export interface NumericOptions<N extends number | bigint> extends SchemaOptions {
     exclusiveMaximum?: N;
     exclusiveMinimum?: N;
@@ -157,15 +157,13 @@ export interface TDate extends TSchema, DateOptions {
     static: Date;
     type: 'date';
 }
-export interface TEnumOption<T> {
-    type: 'number' | 'string';
-    const: T;
-}
-export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
-    [Kind]: 'Union';
-    static: T[keyof T];
-    anyOf: TLiteral<T[keyof T]>[];
-}
+export type TEnumRecord = Record<TEnumKey, TEnumValue>;
+export type TEnumValue = string | number;
+export type TEnumKey = string;
+export type TEnumToLiteralUnion<T extends TEnumValue> = T extends TEnumValue ? TLiteral<T> : never;
+export type TEnumToLiteralTuple<T extends TEnumValue> = UnionToTuple<TEnumToLiteralUnion<T>>;
+export type TEnumToUnion<T extends TEnumValue, R = UnionType<AssertRest<TEnumToLiteralTuple<T>>>> = R extends TLiteralString ? TNever : R;
+export type TEnum<T extends TEnumValue> = Ensure<TEnumToUnion<T>>;
 export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O> : never;
 export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
@@ -776,8 +774,8 @@ export declare class TypeBuilder {
     protected Create<T>(schema: Omit<T, 'static' | 'params'>): T;
     /** `[Internal]` Throws a TypeBuilder error with the given message */
     protected Throw(message: string): never;
-    /** `[Internal]` Discards a property key from the given schema */
-    protected Discard(schema: TSchema, key: PropertyKey): TSchema;
+    /** `[Internal]` Discards property keys from the given record type */
+    protected Discard(record: Record<PropertyKey, any>, keys: PropertyKey[]): any;
     /** `[Json]` Omits compositing symbols from this schema */
     Strict<T extends TSchema>(schema: T): T;
 }
@@ -799,7 +797,7 @@ export declare class JsonTypeBuilder extends TypeBuilder {
     /** `[Json]` Creates a Composite object type */
     Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
     /** `[Json]` Creates a Enum type */
-    Enum<V extends string | number, T extends Record<string, V>>(item: T, options?: SchemaOptions): TEnum<T>;
+    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T[keyof T]>;
     /** `[Json]` Creates a Conditional type */
     Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
     /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */

package/typebox.js

@@ -1874,10 +1874,12 @@ class TypeBuilder {
     Throw(message) {
         throw new TypeBuilderError(message);
     }
-    /** `[Internal]` Discards a property key from the given schema */
-    Discard(schema, key) {
-        const { [key]: _, ...rest } = schema;
-        return rest;
+    /** `[Internal]` Discards property keys from the given record type */
+    Discard(record, keys) {
+        return keys.reduce((acc, key) => {
+            const { [key]: _, ...rest } = acc;
+            return rest;
+        }, record);
     }
     /** `[Json]` Omits compositing symbols from this schema */
     Strict(schema) {
@@ -1932,13 +1934,13 @@ class JsonTypeBuilder extends TypeBuilder {
     }
     /** `[Json]` Creates a Enum type */
     Enum(item, options = {}) {
+        if (ValueGuard.IsUndefined(item))
+            return this.Union([], options);
         // prettier-ignore
-        const values = Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
-        // prettier-ignore
-        const anyOf = values.map((value) => ValueGuard.IsString(value)
-            ? { [exports.Kind]: 'Literal', type: 'string', const: value }
-            : { [exports.Kind]: 'Literal', type: 'number', const: value });
-        return this.Create({ ...options, [exports.Kind]: 'Union', anyOf });
+        const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const values2 = [...new Set(values1)]; // distinct
+        const anyOf = values2.map((value) => exports.Type.Literal(value));
+        return this.Union(anyOf, options);
     }
     /** `[Json]` Creates a Conditional type */
     Extends(left, right, trueType, falseType, options = {}) {
@@ -2076,7 +2078,7 @@ class JsonTypeBuilder extends TypeBuilder {
     Omit(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', exports.Transform]), (object) => {
             if (ValueGuard.IsArray(object.required)) {
                 object.required = object.required.filter((key) => !keys.includes(key));
                 if (object.required.length === 0)
@@ -2092,18 +2094,18 @@ class JsonTypeBuilder extends TypeBuilder {
     /** `[Json]` Constructs a type where all properties are optional */
     Partial(schema, options = {}) {
         // prettier-ignore
-        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', exports.Transform]), (object) => {
             const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
                 return { ...acc, [key]: this.Optional(object.properties[key]) };
             }, {});
-            return this.Object(properties, this.Discard(object, 'required') /* object used as options to retain other constraints */);
+            return this.Object(properties, this.Discard(object, ['required']) /* object used as options to retain other constraints */);
         }, options);
     }
     /** `[Json]` Constructs a type whose keys are picked from the given type */
     Pick(schema, unresolved, options = {}) {
         const keys = KeyArrayResolver.Resolve(unresolved);
         // prettier-ignore
-        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', exports.Transform]), (object) => {
             if (ValueGuard.IsArray(object.required)) {
                 object.required = object.required.filter((key) => keys.includes(key));
                 if (object.required.length === 0)
@@ -2169,9 +2171,9 @@ class JsonTypeBuilder extends TypeBuilder {
     /** `[Json]` Constructs a type where all properties are required */
     Required(schema, options = {}) {
         // prettier-ignore
-        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), exports.Transform), (object) => {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ['$id', exports.Transform]), (object) => {
             const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
-                return { ...acc, [key]: this.Discard(object.properties[key], exports.Optional) };
+                return { ...acc, [key]: this.Discard(object.properties[key], [exports.Optional]) };
             }, {});
             return this.Object(properties, object /* object used as options to retain other constraints  */);
         }, options);