@sinclair/typebox 0.31.6 → 0.31.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.31.6",
+  "version": "0.31.8",
   "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

@@ -440,7 +440,7 @@ export type DecodeProperties<T extends TProperties> = {
     [K in keyof T]: DecodeType<T[K]>;
 };
 export type DecodeRest<T extends TSchema[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DecodeType<L>, ...DecodeRest<R>] : [];
-export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? Array<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<S> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<S> : T extends TUnion<infer S extends TSchema[]> ? TUnion<S> : T);
+export type DecodeType<T extends TSchema> = (T extends TOptional<infer S extends TSchema> ? TOptional<DecodeType<S>> : T extends TReadonly<infer S extends TSchema> ? TReadonly<DecodeType<S>> : T extends TTransform<infer _, infer R> ? TUnsafe<R> : T extends TArray<infer S extends TSchema> ? TArray<DecodeType<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DecodeType<S>> : T extends TConstructor<infer P extends TSchema[], infer R extends TSchema> ? TConstructor<P, DecodeType<R>> : T extends TFunction<infer P extends TSchema[], infer R extends TSchema> ? TFunction<P, DecodeType<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<S> : T extends TIterator<infer S extends TSchema> ? TIterator<DecodeType<S>> : T extends TNot<infer S extends TSchema> ? TNot<DecodeType<S>> : T extends TObject<infer S> ? TObject<Evaluate<DecodeProperties<S>>> : T extends TPromise<infer S extends TSchema> ? TPromise<DecodeType<S>> : T extends TRecord<infer K, infer S> ? TRecord<K, DecodeType<S>> : T extends TRecursive<infer S extends TSchema> ? TRecursive<DecodeType<S>> : T extends TRef<infer S extends TSchema> ? TRef<DecodeType<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<S> : T extends TUnion<infer S extends TSchema[]> ? TUnion<S> : T);
 export type TransformFunction<T = any, U = any> = (value: T) => U;
 export interface TransformOptions<I extends TSchema = TSchema, O extends unknown = unknown> {
     Decode: TransformFunction<StaticDecode<I>, O>;
@@ -776,8 +776,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;
 }

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) {
@@ -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);