@sinclair/typebox 0.28.3 → 0.28.4

package/package.json

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

package/readme.md

@@ -1476,11 +1476,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '126.7 kb' │ ' 56.6 kb' │  '2.24 x'   │
-│ typebox/errors       │ '110.4 kb' │ ' 48.8 kb' │  '2.26 x'   │
-│ typebox/system       │ ' 75.9 kb' │ ' 31.1 kb' │  '2.44 x'   │
-│ typebox/value        │ '176.4 kb' │ ' 76.4 kb' │  '2.31 x'   │
-│ typebox              │ ' 74.8 kb' │ ' 30.7 kb' │  '2.44 x'   │
+│ typebox/compiler     │ '127.1 kb' │ ' 56.7 kb' │  '2.24 x'   │
+│ typebox/errors       │ '110.9 kb' │ ' 48.9 kb' │  '2.27 x'   │
+│ typebox/system       │ ' 76.3 kb' │ ' 31.2 kb' │  '2.44 x'   │
+│ typebox/value        │ '176.8 kb' │ ' 76.5 kb' │  '2.31 x'   │
+│ typebox              │ ' 75.2 kb' │ ' 30.8 kb' │  '2.44 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -34,7 +34,7 @@ export type TOptional<T extends TSchema> = T & {
 export type TReadonlyOptional<T extends TSchema> = T & {
     [Modifier]: 'ReadonlyOptional';
 };
-export type Key = keyof any;
+export type Key = string | number;
 export interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -168,18 +168,20 @@ export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends T
     parameters: T;
     returns: U;
 }
-export type IndexKey = keyof any;
-export type TIndexProperty<T extends TProperties, K extends IndexKey> = K extends keyof T ? [T[K]] : [
+export type TIndexProperty<T extends TProperties, K extends Key> = T[K] extends infer R ? [R] : [
 ];
-export type TIndexTuple<T extends TSchema[], K extends IndexKey> = K extends keyof T ? [T[K]] : [
+export type TIndexTuple<T extends TSchema[], K extends Key> = K extends keyof T ? [T[K]] : [
 ];
-export type TIndexComposite<T extends TSchema[], K extends IndexKey> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : [
+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 IndexKey> = 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 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 IndexKey[]> = K extends [infer L, ...infer R] ? [...TIndexKey<T, Assert<L, IndexKey>>, ...TIndexKeys<T, Assert<R, IndexKey[]>>] : [
+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 TIndex<T extends TSchema, K extends IndexKey[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<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 TIndex<T extends TSchema, K extends Key[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<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 interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -299,7 +301,7 @@ export type RecordTemplateLiteralObjectType<K extends TTemplateLiteral, T extend
     [_ in Static<K>]: T;
 }>>>;
 export type RecordTemplateLiteralType<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends true ? RecordTemplateLiteralObjectType<K, T> : TRecord<K, T>;
-export type RecordUnionLiteralType<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
+export type RecordUnionLiteralType<K extends TUnion, T extends TSchema> = Static<K> extends string ? Ensure<TObject<{
     [X in Static<K>]: T;
 }>> : never;
 export type RecordLiteralType<K extends TLiteral<string | number>, T extends TSchema> = Ensure<TObject<{
@@ -499,8 +501,8 @@ export declare namespace TypeGuard {
     function TLiteralNumber(schema: unknown): schema is TLiteral<number>;
     /** Returns true if the given schema is TLiteral<boolean> */
     function TLiteralBoolean(schema: unknown): schema is TLiteral<boolean>;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
-    function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral<string>[]>;
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
+    function TLiteralUnion(schema: unknown): schema is TUnion<TLiteral[]>;
     /** Returns true if the given schema is TLiteral */
     function TLiteral(schema: unknown): schema is TLiteral;
     /** Returns true if the given schema is TNever */
@@ -568,7 +570,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[]): TSchema[];
+    function Resolve(schema: TSchema, keys: (string | number)[]): TSchema[];
 }
 export declare namespace ObjectMap {
     function Map<T = TSchema>(schema: TSchema, callback: (object: TObject) => TObject, options: SchemaOptions): T;
@@ -586,6 +588,10 @@ export declare namespace KeyArrayResolver {
     /** Resolves an array of string[] keys from the given schema or array type. */
     function Resolve(schema: TSchema | string[]): string[];
 }
+export declare namespace UnionResolver {
+    /** Returns a resolved union with interior unions flattened */
+    function Resolve(union: TUnion): TUnion;
+}
 export declare namespace TemplateLiteralPattern {
     function Create(kinds: TTemplateLiteralKind[]): string;
 }
@@ -651,11 +657,11 @@ 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): TIndex<T, K>;
+    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<string | number>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>;
+    Index<T extends TSchema, K extends TUnion<TLiteral<Key>[]>>(schema: T, keys: K, options?: SchemaOptions): TIndex<T, TLiteralUnion<K>>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TSchema, K extends TLiteral<string | number>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
+    Index<T extends TSchema, K extends TLiteral<Key>>(schema: T, key: K, options?: SchemaOptions): TIndex<T, [K['const']]>;
     /** `[Standard]` Returns indexed property types for the given keys */
     Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>;
     /** `[Standard]` Returns indexed property types for the given keys */
@@ -708,7 +714,7 @@ 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 TNever>(schema: T, key: K, options?: SchemaOptions): TPick<T, never>;
     /** `[Standard]` Creates a Record type */
-    Record<K extends TUnion<TLiteral<string | number>[]>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
+    Record<K extends TUnion, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordUnionLiteralType<K, T>;
     /** `[Standard]` Creates a Record type */
     Record<K extends TLiteral<string | number>, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordLiteralType<K, T>;
     /** `[Standard]` Creates a Record type */

package/typebox.js

@@ -27,7 +27,7 @@ THE SOFTWARE.
 
 ---------------------------------------------------------------------------*/
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
+exports.Type = exports.StandardType = exports.ExtendedTypeBuilder = exports.StandardTypeBuilder = exports.TypeBuilder = exports.TemplateLiteralGenerator = exports.TemplateLiteralFinite = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyResolver = exports.ObjectMap = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.FormatRegistry = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Modifier = void 0;
 // --------------------------------------------------------------------------
 // Symbols
 // --------------------------------------------------------------------------
@@ -324,9 +324,9 @@ var TypeGuard;
         return TKind(schema) && schema[exports.Kind] === 'Literal' && IsOptionalString(schema.$id) && typeof schema.const === 'boolean';
     }
     TypeGuard.TLiteralBoolean = TLiteralBoolean;
-    /** Returns true if the given schema is TUnion<Literal<string>[]> */
+    /** Returns true if the given schema is TUnion<Literal<string | number>[]> */
     function TLiteralUnion(schema) {
-        return TUnion(schema) && schema.anyOf.every((schema) => TLiteral(schema));
+        return TUnion(schema) && schema.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
     }
     TypeGuard.TLiteralUnion = TLiteralUnion;
     /** Returns true if the given schema is TLiteral */
@@ -1411,12 +1411,12 @@ var IndexedAccessor;
         return schema.anyOf.reduce((acc, schema) => [...acc, ...Visit(schema, key)], []);
     }
     function Object(schema, key) {
-        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((k) => k === key);
+        const keys = globalThis.Object.getOwnPropertyNames(schema.properties).filter((key_) => key_ === key);
         return keys.map((key) => schema.properties[key]);
     }
     function Tuple(schema, key) {
         const items = schema.items === undefined ? [] : schema.items;
-        return items.filter((_, index) => index.toString() === key.toString());
+        return items.filter((_, index) => index.toString() === key);
     }
     function Visit(schema, key) {
         if (schema[exports.Kind] === 'Intersect')
@@ -1430,7 +1430,7 @@ var IndexedAccessor;
         return [];
     }
     function Resolve(schema, keys) {
-        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key)], []);
+        return keys.reduce((acc, key) => [...acc, ...Visit(schema, key.toString())], []);
     }
     IndexedAccessor.Resolve = Resolve;
 })(IndexedAccessor = exports.IndexedAccessor || (exports.IndexedAccessor = {}));
@@ -1520,7 +1520,7 @@ var KeyArrayResolver;
         if (globalThis.Array.isArray(schema))
             return schema;
         if (TypeGuard.TLiteralUnion(schema))
-            return schema.anyOf.map((schema) => schema.const);
+            return schema.anyOf.map((schema) => schema.const.toString());
         if (TypeGuard.TLiteral(schema))
             return [schema.const];
         if (TypeGuard.TTemplateLiteral(schema)) {
@@ -1534,6 +1534,27 @@ var KeyArrayResolver;
     KeyArrayResolver.Resolve = Resolve;
 })(KeyArrayResolver = exports.KeyArrayResolver || (exports.KeyArrayResolver = {}));
 // --------------------------------------------------------------------------
+// UnionResolver
+// --------------------------------------------------------------------------
+var UnionResolver;
+(function (UnionResolver) {
+    function* Union(union) {
+        for (const schema of union.anyOf) {
+            if (schema[exports.Kind] === 'Union') {
+                yield* Union(schema);
+            }
+            else {
+                yield schema;
+            }
+        }
+    }
+    /** Returns a resolved union with interior unions flattened */
+    function Resolve(union) {
+        return exports.Type.Union([...Union(union)], { ...union });
+    }
+    UnionResolver.Resolve = Resolve;
+})(UnionResolver = exports.UnionResolver || (exports.UnionResolver = {}));
+// --------------------------------------------------------------------------
 // TemplateLiteralPattern
 // --------------------------------------------------------------------------
 var TemplateLiteralPattern;
@@ -2115,20 +2136,21 @@ class StandardTypeBuilder extends TypeBuilder {
                 ? (this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key) => ({ ...acc, [key]: TypeClone.Clone(schema, {}) }), {}), options))
                 : this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [key.pattern]: TypeClone.Clone(schema, {}) } });
         }
-        else if (TypeGuard.TLiteralUnion(key)) {
-            if (key.anyOf.every((schema) => TypeGuard.TLiteral(schema) && (typeof schema.const === 'string' || typeof schema.const === 'number'))) {
-                const properties = key.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
+        else if (TypeGuard.TUnion(key)) {
+            const union = UnionResolver.Resolve(key);
+            if (TypeGuard.TLiteralUnion(union)) {
+                const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Clone(schema, {}) }), {});
                 return this.Object(properties, { ...options, [exports.Hint]: 'Record' });
             }
             else
-                throw Error('TypeBuilder: Record key can only be derived from union literal of number or string');
+                throw Error('TypeBuilder: Record key of type union contains non-literal types');
         }
         else if (TypeGuard.TLiteral(key)) {
             if (typeof key.const === 'string' || typeof key.const === 'number') {
                 return this.Object({ [key.const]: TypeClone.Clone(schema, {}) }, options);
             }
             else
-                throw Error('TypeBuilder: Record key can only be derived from literals of number or string');
+                throw Error('TypeBuilder: Record key of type literal is not of type string or number');
         }
         else if (TypeGuard.TInteger(key) || TypeGuard.TNumber(key)) {
             const pattern = exports.PatternNumberExact;
@@ -2139,7 +2161,7 @@ class StandardTypeBuilder extends TypeBuilder {
             return this.Create({ ...options, [exports.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: TypeClone.Clone(schema, {}) } });
         }
         else {
-            throw Error(`StandardTypeBuilder: Invalid Record Key`);
+            throw Error(`StandardTypeBuilder: Record key is an invalid type`);
         }
     }
     /** `[Standard]` Creates a Recursive type */