@sinclair/typebox 0.31.8 → 0.31.9

package/package.json

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

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

@@ -1934,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 = {}) {