@sinclair/typebox 0.21.0 → 0.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.21.0",
+  "version": "0.21.1",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "json-schema",

package/readme.md

@@ -774,9 +774,7 @@ type T = Static<typeof T>                // type T = string | null
 //
 //--------------------------------------------------------------------------------------------
 
-type IntoStringUnion<T> = {[K in keyof T]: T[K] extends string ? TLiteral<T[K]>: never }
-
-function StringUnion<T extends string[]>(values: [...T]): TUnion<IntoStringUnion<T>> {
+function StringUnion<T extends string[]>(values: [...T]): TUnion<{[K in keyof T]: T[K] }[number]> {
     return { enum: values } as any
 }
 

package/typebox.d.ts

@@ -63,20 +63,20 @@ export declare type IntersectOptions = {
 export declare type ObjectOptions = {
     additionalProperties?: boolean;
 } & CustomOptions;
+export declare type TDefinitions = {
+    [key: string]: TSchema;
+};
 export declare type TNamespace<T extends TDefinitions> = {
     kind: typeof BoxKind;
     definitions: T;
 } & CustomOptions;
-export declare type TDefinitions = {
-    [key: string]: TSchema;
-};
 export declare type Infer<T> = {
     '_infer': T;
 };
 export declare type TEnumType = Record<string, string | number>;
 export declare type TKey = string | number;
 export declare type TValue = string | number | boolean;
-export declare type TRecordKey = TString | TNumber | TKeyOf<any>;
+export declare type TRecordKey = TString | TNumber | TKeyOf<any> | TUnion<string | number>;
 export declare type TEnumKey<T = TKey> = {
     type: 'number' | 'string';
     const: T;
@@ -84,7 +84,7 @@ export declare type TEnumKey<T = TKey> = {
 export declare type TProperties = {
     [key: string]: TSchema;
 };
-export declare type TTuple<T> = Infer<T> & {
+export declare type TTuple<I> = Infer<I> & {
     kind: typeof TupleKind;
     type: 'array';
     items?: TSchema[];
@@ -92,43 +92,43 @@ export declare type TTuple<T> = Infer<T> & {
     minItems: number;
     maxItems: number;
 } & CustomOptions;
-export declare type TObject<T> = Infer<T> & {
+export declare type TObject<I> = Infer<I> & {
     kind: typeof ObjectKind;
     type: 'object';
     properties: TProperties;
     required?: string[];
 } & ObjectOptions;
-export declare type TUnion<T> = Infer<T> & {
+export declare type TUnion<I> = Infer<I> & {
     kind: typeof UnionKind;
     anyOf: TSchema[];
 } & CustomOptions;
-export declare type TIntersect<T> = Infer<T> & {
+export declare type TIntersect<I> = Infer<I> & {
     kind: typeof IntersectKind;
     type: 'object';
     allOf: TSchema[];
 } & IntersectOptions;
-export declare type TKeyOf<T> = Infer<T> & {
+export declare type TKeyOf<I> = Infer<I> & {
     kind: typeof KeyOfKind;
     type: 'string';
     enum: string[];
 } & CustomOptions;
-export declare type TRecord<T> = Infer<T> & {
+export declare type TRecord<I> = Infer<I> & {
     kind: typeof RecordKind;
     type: 'object';
     patternProperties: {
         [pattern: string]: TSchema;
     };
 } & ObjectOptions;
-export declare type TArray<T> = Infer<T> & {
+export declare type TArray<I> = Infer<I> & {
     kind: typeof ArrayKind;
     type: 'array';
     items: any;
 } & ArrayOptions;
-export declare type TLiteral<T> = Infer<T> & {
+export declare type TLiteral<I> = Infer<I> & {
     kind: typeof LiteralKind;
-    const: TSchema;
+    const: TValue;
 } & CustomOptions;
-export declare type TEnum<T> = Infer<T> & {
+export declare type TEnum<I> = Infer<I> & {
     kind: typeof EnumKind;
     anyOf: TSchema;
 } & CustomOptions;
@@ -219,7 +219,7 @@ export declare type StaticTuple<T extends readonly TSchema[]> = {
     [K in keyof T]: Static<T[K]>;
 };
 export declare type StaticObject<T extends TProperties> = StaticProperties<StaticProperties<T>>;
-export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K extends TString ? Record<string, Static<T>> : K extends TNumber ? Record<number, Static<T>> : K extends TKeyOf<any> ? Record<K['_infer'], Static<T>> : never;
+export declare type StaticRecord<K extends TRecordKey, T extends TSchema> = K extends TString ? Record<string, Static<T>> : K extends TNumber ? Record<number, Static<T>> : K extends TKeyOf<any> ? Record<K['_infer'], Static<T>> : K extends TUnion<any> ? Record<K['_infer'], Static<T>> : never;
 export declare type StaticArray<T extends TSchema> = Array<Static<T>>;
 export declare type StaticLiteral<T extends TValue> = T;
 export declare type StaticConstructor<T extends readonly TSchema[], U extends TSchema> = new (...args: [...{

package/typebox.js

@@ -55,7 +55,7 @@ exports.NullKind = Symbol('NullKind');
 exports.UnknownKind = Symbol('UnknownKind');
 exports.AnyKind = Symbol('AnyKind');
 // ------------------------------------------------------------------------
-// Schema Extended
+// Extended Schema Types
 // ------------------------------------------------------------------------
 exports.ConstructorKind = Symbol('ConstructorKind');
 exports.FunctionKind = Symbol('FunctionKind');
@@ -179,9 +179,15 @@ class TypeBuilder {
     }
     /** `standard` Creates a record type */
     Record(key, value, options = {}) {
-        const pattern = key.kind === exports.KeyOfKind ? `^${key.enum.join('|')}$` :
-            key.kind === exports.NumberKind ? '^(0|[1-9][0-9]*)$' :
-                key.pattern ? key.pattern : '^.*$';
+        const pattern = (() => {
+            switch (key.kind) {
+                case exports.UnionKind: return `^${key.anyOf.map(literal => literal.const).join('|')}$`;
+                case exports.KeyOfKind: return `^${key.enum.join('|')}$`;
+                case exports.NumberKind: return '^(0|[1-9][0-9]*)$';
+                case exports.StringKind: return key.pattern ? key.pattern : '^.*$';
+                default: throw Error('Invalid Record Key');
+            }
+        })();
         return { ...options, kind: exports.RecordKind, type: 'object', patternProperties: { [pattern]: value } };
     }
     /** `standard` Makes all properties in the given object type required */