@sinclair/typebox 0.28.5 → 0.28.6

package/package.json

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

package/readme.md

@@ -11,6 +11,8 @@
 
 [![npm version](https://badge.fury.io/js/%40sinclair%2Ftypebox.svg)](https://badge.fury.io/js/%40sinclair%2Ftypebox)
 [![Downloads](https://img.shields.io/npm/dm/%40sinclair%2Ftypebox.svg)](https://www.npmjs.com/package/%40sinclair%2Ftypebox)
+[![Install Size](https://packagephobia.com/badge?p=@sinclair/typebox)](https://packagephobia.com/result?p=@sinclair/typebox)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub CI](https://github.com/sinclairzx81/typebox/workflows/GitHub%20CI/badge.svg)](https://github.com/sinclairzx81/typebox/actions)
 
 </div>
@@ -1369,9 +1371,15 @@ const B = Value.Check(T, 'hello')                    // const B = true
 
 ### Policies
 
-TypeBox validates using JSON Schema assertion policies by default. It is possible to override these policies and have TypeBox assert using TypeScript policies. The following overrides are available.
+TypeBox validates using standard JSON Schema assertion policies by default. It is possible to override some of these policies to have TypeBox assert inline with TypeScript static assertion rules. The following policy overrides are available.
 
 ```typescript
+// Disallow undefined values for optional properties (default is false)
+//
+// const A: { x?: number } = { x: undefined } - disallowed when enabled
+
+TypeSystem.ExactOptionalPropertyTypes = true
+
 // Allow arrays to validate as object types (default is false)
 //
 // const A: {} = [] - allowed in TS

package/typebox.d.ts

@@ -14,6 +14,8 @@ export type TupleToUnion<T extends any[]> = {
 export type UnionToIntersect<U> = (U extends unknown ? (arg: U) => 0 : never) extends (arg: infer I) => 0 ? I : never;
 export type UnionLast<U> = UnionToIntersect<U extends unknown ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L : never;
 export type UnionToTuple<U, L = UnionLast<U>> = [U] extends [never] ? [] : [...UnionToTuple<Exclude<U, L>>, L];
+export type Discard<T extends unknown[], D extends unknown> = T extends [infer L, ...infer R] ? (L extends D ? Discard<R, D> : [L, ...Discard<R, D>]) : [];
+export type Flat<T> = T extends [] ? [] : T extends [infer L] ? [...Flat<L>] : T extends [infer L, ...infer R] ? [...Flat<L>, ...Flat<R>] : [T];
 export type Assert<T, E> = T extends E ? T : never;
 export type Evaluate<T> = T extends infer O ? {
     [K in keyof O]: O[K];
@@ -168,27 +170,21 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
     parameters: T;
     returns: U;
 }
-export type TIndexProperty<T extends TProperties, K extends Key> = T[K] extends infer R ? [R] : [
+export type TIndexRest<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [TIndexType<AssertType<L>, K>, ...TIndexRest<AssertRest<R>, K>] : [];
+export type TIndexProperty<T extends TProperties, K extends Key> = K extends keyof T ? [T[K]] : [];
+export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [];
+export type TIndexType<T extends TSchema, K extends Key> = T extends TRecursive<infer S> ? TIndexType<S, K> : T extends TIntersect<infer S> ? IntersectType<AssertRest<Discard<Flat<TIndexRest<S, K>>, TNever>>> : T extends TUnion<infer S> ? UnionType<AssertRest<Flat<TIndexRest<S, K>>>> : T extends TObject<infer S> ? UnionType<AssertRest<Flat<TIndexProperty<S, K>>>> : T extends TTuple<infer S> ? UnionType<AssertRest<Flat<TIndexTuple<S, K>>>> : [
 ];
-export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [
+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 TIndexComposite<T extends TSchema[], K extends Key> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : [
-];
-export type TIndexKey<T extends TSchema, K extends Key> = T extends TRecursive<infer S> ? TIndexKey<S, K> : T extends TIntersect<infer S> ? TIndexComposite<S, K> : T extends TUnion<infer S> ? TIndexComposite<S, K> : T extends TObject<infer S> ? TIndexProperty<S, K> : T extends TTuple<infer S> ? TIndexTuple<S, K> : T extends TArray<infer S> ? S : [
-];
-export type TIndexKeys<T extends TSchema, K extends Key[]> = K extends [infer L, ...infer R] ? [
-    ...TIndexKey<T, Assert<L, Key>>,
-    ...TIndexKeys<T, Assert<R, Key[]>>
-] : [
-];
-export type TIndexFromKeyTuple<T extends TSchema, K extends Key[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndexFromKeyTuple<S, K> : T extends TTuple ? UnionType<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
+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 ? TIndexFromKeyTuple<T, TTemplateLiteralKeyTuple<K>> : K extends TUnion<TLiteral<Key>[]> ? TIndexFromKeyTuple<T, TUnionLiteral<K>> : K extends TLiteral<Key> ? TIndexFromKeyTuple<T, [K['const']]> : TNever;
+] 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 interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -379,7 +375,7 @@ export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infe
     [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
-export type TTemplateLiteralKeyTuple<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
+export type TTemplateLiteralKeyRest<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
@@ -405,7 +401,7 @@ export interface TUndefined extends TSchema {
 }
 export type TLiteralUnionReduce<T extends TLiteral<string | number>[]> = T extends [infer L, ...infer R] ? [Assert<L, TLiteral<string | number>>['const'], ...TLiteralUnionReduce<Assert<R, TLiteral<string | number>[]>>] : [
 ];
-export type TUnionLiteral<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [
+export type TUnionLiteralKeyRest<T extends TUnion<TLiteral<string | number>[]>> = T extends TUnion<infer S> ? TLiteralUnionReduce<Assert<S, TLiteral<string | number>[]>> : [
 ];
 export type TUnionTemplateLiteral<T extends TTemplateLiteral, S extends string = Static<T>> = Ensure<UnionType<Assert<UnionToTuple<{
     [K in S]: TLiteral<K>;
@@ -444,7 +440,7 @@ export interface TVoid extends TSchema {
     type: 'null';
     typeOf: 'Void';
 }
-/** Creates a TypeScript static type from a TypeBox type */
+/** Infers a static type from a TypeBox type */
 export type Static<T extends TSchema, P extends unknown[] = []> = (T & {
     params: P;
 })['static'];
@@ -577,7 +573,7 @@ export declare namespace TypeClone {
     function Clone<T extends TSchema>(schema: T, options: SchemaOptions): T;
 }
 export declare namespace IndexedAccessor {
-    function Resolve(schema: TSchema, keys: (string | number)[]): TSchema[];
+    function Resolve(schema: TSchema, keys: Key[], options?: SchemaOptions): TSchema;
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -664,7 +660,7 @@ 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): TIndexFromKeyTuple<T, Assert<K, Key[]>>;
+    Index<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: [...K], options?: SchemaOptions): TIndexReduce<T, Assert<K, Key[]>>;
     /** `[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>;
     /** `[Standard]` Creates an Integer type */
@@ -691,11 +687,11 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TOmit<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteral<K>[number]>;
+    Omit<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TOmit<T, TUnionLiteralKeyRest<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TOmit<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyTuple<K>[number]>;
+    Omit<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TOmit<T, TTemplateLiteralKeyRest<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are omitted from the given type */
     Omit<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TOmit<T, never>;
     /** `[Standard]` Creates a mapped type where all properties are Optional */
@@ -703,11 +699,11 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends (keyof Static<T>)[]>(schema: T, keys: readonly [...K], options?: SchemaOptions): TPick<T, K[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteral<K>[number]>;
+    Pick<T extends TSchema, K extends TUnion<TLiteral<string>[]>>(schema: T, keys: K, options?: SchemaOptions): TPick<T, TUnionLiteralKeyRest<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TLiteral<string>>(schema: T, key: K, options?: SchemaOptions): TPick<T, K['const']>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyTuple<K>[number]>;
+    Pick<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TPick<T, TTemplateLiteralKeyRest<K>[number]>;
     /** `[Standard]` Creates a mapped type whose keys are picked from the given type */
     Pick<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
     /** `[Standard]` Creates a Record type */

package/typebox.js

@@ -1405,18 +1405,28 @@ var TypeClone;
 var IndexedAccessor;
 (function (IndexedAccessor) {
     function Intersect(schema, key) {
-        return schema.allOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+        const schemas = schema.allOf.reduce((acc, schema) => {
+            const indexed = Visit(schema, key);
+            return indexed[exports.Kind] === 'Never' ? acc : [...acc, indexed];
+        }, []);
+        return exports.Type.Intersect(schemas);
     }
     function Union(schema, key) {
-        return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
+        const schemas = schema.anyOf.map((schema) => Visit(schema, key));
+        return exports.Type.Union(schemas);
     }
     function Object(schema, key) {
-        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key);
-        return keys.map((key) => schema.properties[key]);
+        const property = schema.properties[key];
+        return property === undefined ? exports.Type.Never() : exports.Type.Union([property]);
     }
     function Tuple(schema, key) {
-        const items = schema.items === undefined ? [] : schema.items;
-        return items.filter((_, index) => index.toString() === key);
+        const items = schema.items;
+        if (items === undefined)
+            return exports.Type.Never();
+        const element = items[key]; //
+        if (element === undefined)
+            return exports.Type.Never();
+        return element;
     }
     function Visit(schema, key) {
         if (schema[exports.Kind] === 'Intersect')
@@ -1427,10 +1437,10 @@ var IndexedAccessor;
             return Object(schema, key);
         if (schema[exports.Kind] === 'Tuple')
             return Tuple(schema, key);
-        return [];
+        return exports.Type.Never();
     }
-    function Resolve(schema, keys) {
-        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], []);
+    function Resolve(schema, keys, options = {}) {
+        return exports.Type.Union(keys.map((key) => Visit(schema, key.toString())));
     }
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
@@ -1977,18 +1987,19 @@ class StandardTypeBuilder extends TypeBuilder {
     }
     /** `[Standard]` Returns indexed property types for the given keys */
     Index(schema, unresolved, options = {}) {
-        const keys = KeyArrayResolver.Resolve(unresolved);
         if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
             return TypeClone.Clone(schema.items, options);
         }
-        if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
+        else if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
             const items = schema.items === undefined ? [] : schema.items;
             const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
             return this.Union(cloned, options);
         }
-        const resolved = IndexedAccessor.Resolve(schema, keys);
-        const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}));
-        return this.Union(cloned, options);
+        else {
+            const keys = KeyArrayResolver.Resolve(unresolved);
+            const clone = TypeClone.Clone(schema, {});
+            return IndexedAccessor.Resolve(clone, keys, options);
+        }
     }
     /** `[Standard]` Creates an Integer type */
     Integer(options = {}) {