typebox 1.0.13 → 1.0.14

package/build/type/engine/enum/typescript-enum-to-enum-values.d.mts

@@ -1,7 +1,8 @@
 import { type TEnumValue } from '../../types/enum.mjs';
 import { type TUnionToTuple } from '../helpers/union.mjs';
-export type TTSEnumLike = Record<PropertyKey, TEnumValue>;
-type TReduceEnumValues<Keys extends string[], Type extends TTSEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
-export type TTSEnumToEnumValues<Type extends TTSEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
-export declare function TSEnumToEnumValues<Type extends TTSEnumLike>(type: Type): TTSEnumToEnumValues<Type>;
+export type TTypeScriptEnumLike = Record<PropertyKey, TEnumValue>;
+export declare function IsTypeScriptEnumLike(value: unknown): value is TTypeScriptEnumLike;
+type TReduceEnumValues<Keys extends string[], Type extends TTypeScriptEnumLike, Result extends TEnumValue[] = []> = (Keys extends [infer Left extends string, ...infer Right extends string[]] ? TReduceEnumValues<Right, Type, [...Result, Type[Left]]> : Result);
+export type TTypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike, EnumKeys extends string[] = TUnionToTuple<Extract<keyof Type, string>>, Elements extends TEnumValue[] = TReduceEnumValues<EnumKeys, Type>> = Elements;
+export declare function TypeScriptEnumToEnumValues<Type extends TTypeScriptEnumLike>(type: Type): TTypeScriptEnumToEnumValues<Type>;
 export {};

package/build/type/engine/enum/typescript-enum-to-enum-values.mjs

@@ -1,6 +1,9 @@
 // deno-fmt-ignore-file
 import { Guard } from '../../../guard/index.mjs';
-export function TSEnumToEnumValues(type) {
+export function IsTypeScriptEnumLike(value) {
+    return Guard.IsObjectNotArray(value);
+}
+export function TypeScriptEnumToEnumValues(type) {
     const keys = Guard.Keys(type).filter((key) => isNaN(key));
     return keys.reduce((result, key) => [...result, type[key]], []);
 }

package/build/type/types/enum.d.mts

@@ -1,5 +1,6 @@
 import { type TSchema, type TSchemaOptions } from './schema.mjs';
-import { type TTSEnumToEnumValues, type TTSEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { type TTypeScriptEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
 export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
 export type TEnumValue = string | number | null;
 /** Represents an Enum type. */
@@ -8,8 +9,8 @@ export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSche
     enum: Values;
 }
 /** Creates an Enum type. */
-export declare function Enum<Enum extends TTSEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTSEnumToEnumValues<Enum>>;
-/** Creates an Enum type. */
-export declare function Enum<Values extends TEnumValue[]>(values: [...Values], options?: TSchemaOptions): TEnum<Values>;
+export declare function Enum<Values extends TEnumValue[]>(values: readonly [...Values], options?: TSchemaOptions): TEnum<Values>;
+/** Creates an Enum type from a TypeScript enum declaration. */
+export declare function Enum<Enum extends TTypeScriptEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTypeScriptEnumToEnumValues<Enum>>;
 /** Returns true if the given value is a TEnum. */
 export declare function IsEnum(value: unknown): value is TEnum;

package/build/type/types/enum.mjs

@@ -1,11 +1,11 @@
 // deno-fmt-ignore-file
 import { Memory } from '../../system/memory/index.mjs';
-import { Guard } from '../../guard/index.mjs';
 import { IsKind } from './schema.mjs';
-import { TSEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { IsTypeScriptEnumLike } from '../engine/enum/typescript-enum-to-enum-values.mjs';
+import { TypeScriptEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values.mjs';
 /** Creates an Enum type. */
 export function Enum(value, options) {
-    const values = Guard.IsArray(value) ? value : TSEnumToEnumValues(value);
+    const values = IsTypeScriptEnumLike(value) ? TypeScriptEnumToEnumValues(value) : value;
     return Memory.Create({ '~kind': 'Enum' }, { enum: values }, options);
 }
 // ------------------------------------------------------------------

package/build/type/types/record.d.mts

@@ -6,7 +6,7 @@ import { type TNumber } from './number.mjs';
 import { type TString } from './string.mjs';
 import { type TDeferred } from './deferred.mjs';
 import { type TInstantiate } from '../engine/instantiate.mjs';
-export type StaticRecord<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticValue extends unknown = StaticType<Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = (Key extends TStringKey ? Record<string, StaticValue> : Key extends TIntegerKey ? Record<number, StaticValue> : Key extends TNumberKey ? Record<number, StaticValue> : Record<PropertyKey, StaticValue>)> = Result;
+export type StaticRecord<Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticValue extends unknown = StaticType<Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = (Key extends TStringKey ? Record<string, StaticValue> : Key extends TIntegerKey ? Record<number, StaticValue> : Key extends TNumberKey ? Record<number, StaticValue> : Record<string, StaticValue>)> = Result;
 export type TStringKey = typeof StringKey;
 export type TIntegerKey = typeof IntegerKey;
 export type TNumberKey = typeof NumberKey;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "typebox",
   "description": "A Runtime Type System for JavaScript",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "keywords": [
     "typescript",
     "jsonschema"