@nmtjs/type 0.3.10 → 0.4.0

package/dist/compiler.js

@@ -1,37 +1,35 @@
 import { TypeCompiler } from '@sinclair/typebox/compiler';
 import { Value } from '@sinclair/typebox/value';
 import { getTypeSchema } from "./types/base.js";
-const compileType = (type)=>{
+function _prepare(schema, value) {
+    return Value.Default(schema, Value.Clean(schema, value));
+}
+function _convert(schema, value) {
+    return Value.Convert(schema, value);
+}
+function compileType(type) {
     const schema = getTypeSchema(type);
     const compiled = TypeCompiler.Compile(schema);
-    const prepare = (value)=>{
-        for (const fn of [
-            Value.Clean,
-            Value.Default
-        ]){
-            value = fn(schema, value);
-        }
-        return value;
-    };
-    const convert = (value)=>Value.Convert(schema, value);
     return {
         check: compiled.Check.bind(compiled),
         errors: compiled.Errors.bind(compiled),
         decode: compiled.Decode.bind(compiled),
         encode: compiled.Encode.bind(compiled),
-        prepare,
-        convert
+        prepare: _prepare.bind(null, schema),
+        convert: _convert.bind(null, schema)
     };
-};
-export const compile = (schema)=>{
+}
+export function compile(schema) {
     const compiled = compileType(schema);
     return {
         ...compiled,
-        decode: (val)=>{
+        decode: (val)=>compiled.decode(val),
+        encode: (val)=>compiled.encode(val),
+        decodeSafe: (val)=>{
             try {
                 return {
                     success: true,
-                    value: compiled.decode(compiled.prepare(val))
+                    value: compiled.decode(val)
                 };
             } catch (error) {
                 return {
@@ -40,11 +38,11 @@ export const compile = (schema)=>{
                 };
             }
         },
-        encode: (val)=>{
+        encodeSafe: (val)=>{
             try {
                 return {
                     success: true,
-                    value: compiled.encode(compiled.prepare(val))
+                    value: compiled.encode(val)
                 };
             } catch (error) {
                 return {
@@ -54,4 +52,31 @@ export const compile = (schema)=>{
             }
         }
     };
-};
+}
+export var runtime;
+(function(runtime) {
+    function prepare(type, value) {
+        return _prepare(getTypeSchema(type), value);
+    }
+    runtime.prepare = prepare;
+    function convert(type, value) {
+        return _convert(getTypeSchema(type), value);
+    }
+    runtime.convert = convert;
+    function errors(type, value) {
+        return Value.Errors(getTypeSchema(type), value);
+    }
+    runtime.errors = errors;
+    function check(type, value) {
+        return Value.Check(getTypeSchema(type), value);
+    }
+    runtime.check = check;
+    function decode(type, value) {
+        return Value.Decode(getTypeSchema(type), value);
+    }
+    runtime.decode = decode;
+    function encode(type, value) {
+        return Value.Encode(getTypeSchema(type), value);
+    }
+    runtime.encode = encode;
+})(runtime || (runtime = {}));

package/dist/compiler.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/compiler.ts"],"sourcesContent":["import {\n  TypeCompiler,\n  type ValueErrorIterator,\n} from '@sinclair/typebox/compiler'\nimport { Value } from '@sinclair/typebox/value'\nimport { type BaseType, getTypeSchema } from './types/base.ts'\n\nexport type Compiled = {\n  check: (val: unknown) => boolean\n  errors: (val: unknown) => ValueErrorIterator\n  prepare: (val: unknown) => unknown\n  convert: (val: unknown) => unknown\n  decode: (\n    val: unknown,\n  ) => { success: true; value: unknown } | { success: false; error: any }\n  encode: (\n    val: unknown,\n  ) => { success: true; value: unknown } | { success: false; error: any }\n}\n\nconst compileType = (type: BaseType) => {\n  const schema = getTypeSchema(type)\n  const compiled = TypeCompiler.Compile(schema)\n  const prepare = (value: any) => {\n    for (const fn of [Value.Clean, Value.Default]) {\n      value = fn(schema, value)\n    }\n    return value\n  }\n  const convert = (value: any) => Value.Convert(schema, value)\n  return {\n    check: compiled.Check.bind(compiled),\n    errors: compiled.Errors.bind(compiled),\n    decode: compiled.Decode.bind(compiled),\n    encode: compiled.Encode.bind(compiled),\n    prepare,\n    convert,\n  }\n}\n\nexport const compile = (schema: BaseType): Compiled => {\n  const compiled = compileType(schema)\n\n  // TODO: custom error handling/shaping\n  return {\n    ...compiled,\n    decode: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.decode(compiled.prepare(val)),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n    encode: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.encode(compiled.prepare(val)),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n  }\n}\n"],"names":["TypeCompiler","Value","getTypeSchema","compileType","type","schema","compiled","Compile","prepare","value","fn","Clean","Default","convert","Convert","check","Check","bind","errors","Errors","decode","Decode","encode","Encode","compile","val","success","error"],"mappings":"AAAA,SACEA,YAAY,QAEP,6BAA4B;AACnC,SAASC,KAAK,QAAQ,0BAAyB;AAC/C,SAAwBC,aAAa,QAAQ,kBAAiB;AAe9D,MAAMC,cAAc,CAACC;IACnB,MAAMC,SAASH,cAAcE;IAC7B,MAAME,WAAWN,aAAaO,OAAO,CAACF;IACtC,MAAMG,UAAU,CAACC;QACf,KAAK,MAAMC,MAAM;YAACT,MAAMU,KAAK;YAAEV,MAAMW,OAAO;SAAC,CAAE;YAC7CH,QAAQC,GAAGL,QAAQI;QACrB;QACA,OAAOA;IACT;IACA,MAAMI,UAAU,CAACJ,QAAeR,MAAMa,OAAO,CAACT,QAAQI;IACtD,OAAO;QACLM,OAAOT,SAASU,KAAK,CAACC,IAAI,CAACX;QAC3BY,QAAQZ,SAASa,MAAM,CAACF,IAAI,CAACX;QAC7Bc,QAAQd,SAASe,MAAM,CAACJ,IAAI,CAACX;QAC7BgB,QAAQhB,SAASiB,MAAM,CAACN,IAAI,CAACX;QAC7BE;QACAK;IACF;AACF;AAEA,OAAO,MAAMW,UAAU,CAACnB;IACtB,MAAMC,WAAWH,YAAYE;IAG7B,OAAO;QACL,GAAGC,QAAQ;QACXc,QAAQ,CAACK;YACP,IAAI;gBACF,OAAO;oBACLC,SAAS;oBACTjB,OAAOH,SAASc,MAAM,CAACd,SAASE,OAAO,CAACiB;gBAC1C;YACF,EAAE,OAAOE,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;QACAL,QAAQ,CAACG;YACP,IAAI;gBACF,OAAO;oBACLC,SAAS;oBACTjB,OAAOH,SAASgB,MAAM,CAAChB,SAASE,OAAO,CAACiB;gBAC1C;YACF,EAAE,OAAOE,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../src/compiler.ts"],"sourcesContent":["import type { TSchema } from '@sinclair/typebox'\nimport {\n  TypeCompiler,\n  type ValueErrorIterator,\n} from '@sinclair/typebox/compiler'\nimport { Value } from '@sinclair/typebox/value'\nimport type { typeStatic } from './constants.ts'\nimport { type BaseType, getTypeSchema } from './types/base.ts'\n\nexport type Compiled<T extends BaseType = BaseType> = {\n  check: (val: unknown) => boolean\n  errors: (val: unknown) => ValueErrorIterator\n  prepare: (val: unknown) => unknown\n  convert: (val: unknown) => unknown\n  decode: (val: unknown) => T[typeStatic]['decoded']\n  encode: (val: unknown) => T[typeStatic]['encoded']\n  decodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: T[typeStatic]['decoded'] }\n    | { success: false; error: any }\n  encodeSafe: (\n    val: unknown,\n  ) =>\n    | { success: true; value: T[typeStatic]['encoded'] }\n    | { success: false; error: any }\n}\n\nfunction _prepare(schema: TSchema, value: any) {\n  return Value.Default(schema, Value.Clean(schema, value))\n}\n\nfunction _convert(schema: TSchema, value: any) {\n  return Value.Convert(schema, value)\n}\n\nfunction compileType(type: BaseType) {\n  const schema = getTypeSchema(type)\n  const compiled = TypeCompiler.Compile(schema)\n  return {\n    check: compiled.Check.bind(compiled),\n    errors: compiled.Errors.bind(compiled),\n    decode: compiled.Decode.bind(compiled),\n    encode: compiled.Encode.bind(compiled),\n    prepare: _prepare.bind(null, schema),\n    convert: _convert.bind(null, schema),\n  }\n}\n\nexport function compile<T extends BaseType>(schema: T): Compiled<T> {\n  const compiled = compileType(schema)\n\n  // TODO: custom error handling/shaping\n  return {\n    ...compiled,\n    decode: (val) => compiled.decode(val),\n    encode: (val) => compiled.encode(val),\n    decodeSafe: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.decode(val),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n    encodeSafe: (val) => {\n      try {\n        return {\n          success: true as const,\n          value: compiled.encode(val),\n        }\n      } catch (error) {\n        return { success: false as const, error }\n      }\n    },\n  }\n}\n\nexport namespace runtime {\n  export function prepare(type: BaseType, value: any) {\n    return _prepare(getTypeSchema(type), value)\n  }\n\n  export function convert(type: BaseType, value: any) {\n    return _convert(getTypeSchema(type), value)\n  }\n\n  export function errors(type: BaseType, value: any): ValueErrorIterator {\n    return Value.Errors(getTypeSchema(type), value)\n  }\n\n  export function check(type: BaseType, value: any): boolean {\n    return Value.Check(getTypeSchema(type), value)\n  }\n\n  export function decode<T extends BaseType>(\n    type: BaseType,\n    value: any,\n  ): T[typeStatic]['decoded'] {\n    return Value.Decode(getTypeSchema(type), value)\n  }\n\n  export function encode<T extends BaseType>(\n    type: T,\n    value: any,\n  ): T[typeStatic]['encoded'] {\n    return Value.Encode(getTypeSchema(type), value)\n  }\n}\n"],"names":["TypeCompiler","Value","getTypeSchema","_prepare","schema","value","Default","Clean","_convert","Convert","compileType","type","compiled","Compile","check","Check","bind","errors","Errors","decode","Decode","encode","Encode","prepare","convert","compile","val","decodeSafe","success","error","encodeSafe","runtime"],"mappings":"AACA,SACEA,YAAY,QAEP,6BAA4B;AACnC,SAASC,KAAK,QAAQ,0BAAyB;AAE/C,SAAwBC,aAAa,QAAQ,kBAAiB;AAqB9D,SAASC,SAASC,MAAe,EAAEC,KAAU;IAC3C,OAAOJ,MAAMK,OAAO,CAACF,QAAQH,MAAMM,KAAK,CAACH,QAAQC;AACnD;AAEA,SAASG,SAASJ,MAAe,EAAEC,KAAU;IAC3C,OAAOJ,MAAMQ,OAAO,CAACL,QAAQC;AAC/B;AAEA,SAASK,YAAYC,IAAc;IACjC,MAAMP,SAASF,cAAcS;IAC7B,MAAMC,WAAWZ,aAAaa,OAAO,CAACT;IACtC,OAAO;QACLU,OAAOF,SAASG,KAAK,CAACC,IAAI,CAACJ;QAC3BK,QAAQL,SAASM,MAAM,CAACF,IAAI,CAACJ;QAC7BO,QAAQP,SAASQ,MAAM,CAACJ,IAAI,CAACJ;QAC7BS,QAAQT,SAASU,MAAM,CAACN,IAAI,CAACJ;QAC7BW,SAASpB,SAASa,IAAI,CAAC,MAAMZ;QAC7BoB,SAAShB,SAASQ,IAAI,CAAC,MAAMZ;IAC/B;AACF;AAEA,OAAO,SAASqB,QAA4BrB,MAAS;IACnD,MAAMQ,WAAWF,YAAYN;IAG7B,OAAO;QACL,GAAGQ,QAAQ;QACXO,QAAQ,CAACO,MAAQd,SAASO,MAAM,CAACO;QACjCL,QAAQ,CAACK,MAAQd,SAASS,MAAM,CAACK;QACjCC,YAAY,CAACD;YACX,IAAI;gBACF,OAAO;oBACLE,SAAS;oBACTvB,OAAOO,SAASO,MAAM,CAACO;gBACzB;YACF,EAAE,OAAOG,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;QACAC,YAAY,CAACJ;YACX,IAAI;gBACF,OAAO;oBACLE,SAAS;oBACTvB,OAAOO,SAASS,MAAM,CAACK;gBACzB;YACF,EAAE,OAAOG,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;IACF;AACF;;UAEiBE;IACR,SAASR,QAAQZ,IAAc,EAAEN,KAAU;QAChD,OAAOF,SAASD,cAAcS,OAAON;IACvC;YAFgBkB,UAAAA;IAIT,SAASC,QAAQb,IAAc,EAAEN,KAAU;QAChD,OAAOG,SAASN,cAAcS,OAAON;IACvC;YAFgBmB,UAAAA;IAIT,SAASP,OAAON,IAAc,EAAEN,KAAU;QAC/C,OAAOJ,MAAMiB,MAAM,CAAChB,cAAcS,OAAON;IAC3C;YAFgBY,SAAAA;IAIT,SAASH,MAAMH,IAAc,EAAEN,KAAU;QAC9C,OAAOJ,MAAMc,KAAK,CAACb,cAAcS,OAAON;IAC1C;YAFgBS,QAAAA;IAIT,SAASK,OACdR,IAAc,EACdN,KAAU;QAEV,OAAOJ,MAAMmB,MAAM,CAAClB,cAAcS,OAAON;IAC3C;YALgBc,SAAAA;IAOT,SAASE,OACdV,IAAO,EACPN,KAAU;QAEV,OAAOJ,MAAMqB,MAAM,CAACpB,cAAcS,OAAON;IAC3C;YALgBgB,SAAAA;AAMlB,GA9BiBU,YAAAA"}

package/dist/types/enum.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import type { SchemaOptions } from '@sinclair/typebox'\nimport type { TNativeEnum } from '../schemas/native-enum.ts'\nimport { NativeEnum } from '../schemas/native-enum.ts'\nimport { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'\nimport { BaseType } from './base.ts'\n\nexport type AnyObjectEnumType<T extends { [K in string]: K } = any> =\n  ObjectEnumType<T, boolean, boolean, boolean>\nexport class ObjectEnumType<\n  T extends { [K in string]: K },\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TNativeEnum<T>, N, O, D> {\n  constructor(\n    protected readonly values: T,\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    values: T,\n  ): TNativeEnum<T> {\n    return NativeEnum(values, options)\n  }\n\n  nullable() {\n    return new ObjectEnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectEnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: keyof T) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: (keyof T)[]) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n\nexport type AnyEnumType = EnumType<any[], boolean, boolean, boolean>\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TUnionEnum<T>, N, O, D> {\n  constructor(\n    protected readonly values: [...T],\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    values: [...T],\n  ): TUnionEnum<T> {\n    return UnionEnum(values, options)\n  }\n\n  nullable() {\n    return new EnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new EnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new EnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: T[number]) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: [T[number], ...T[number][]]) {\n    return new EnumType(this.values, ...this._with({ options: { examples } }))\n  }\n}\n"],"names":["NativeEnum","UnionEnum","BaseType","ObjectEnumType","constructor","values","options","isNullable","isOptional","hasDefault","_constructSchema","nullable","_with","optional","nullish","default","value","description","examples","EnumType"],"mappings":"AAEA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAA0BC,SAAS,QAAQ,2BAA0B;AACrE,SAASC,QAAQ,QAAQ,YAAW;AAIpC,OAAO,MAAMC,uBAKHD;;IACRE,YACE,AAAmBC,MAAS,EAC5BC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aANhCA,SAAAA;IAOrB;IAEUK,iBACRJ,OAAsB,EACtBD,MAAS,EACO;QAChB,OAAOL,WAAWK,QAAQC;IAC5B;IAEAK,WAAW;QACT,OAAO,IAAIR,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IAC1E;IAEAM,WAAW;QACT,OAAO,IAAIV,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IAC1E;IAEAM,UAAU;QACR,OAAO,IAAIX,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAc,EAAE;QACtB,OAAO,IAAIb,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqB,EAAE;QACjC,OAAO,IAAIf,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IAE1C;AACF;AAGA,OAAO,MAAMC,iBAKHjB;;IACRE,YACE,AAAmBC,MAAc,EACjCC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aANhCA,SAAAA;IAOrB;IAEUK,iBACRJ,OAAsB,EACtBD,MAAc,EACC;QACf,OAAOJ,UAAUI,QAAQC;IAC3B;IAEAK,WAAW;QACT,OAAO,IAAIQ,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IACpE;IAEAM,WAAW;QACT,OAAO,IAAIM,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IACpE;IAEAM,UAAU;QACR,OAAO,IAAIK,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAgB,EAAE;QACxB,OAAO,IAAIG,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAIE,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqC,EAAE;QACjD,OAAO,IAAIC,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IACzE;AACF"}
+{"version":3,"sources":["../../../src/types/enum.ts"],"sourcesContent":["import type { SchemaOptions } from '@sinclair/typebox'\nimport type { TNativeEnum } from '../schemas/native-enum.ts'\nimport { NativeEnum } from '../schemas/native-enum.ts'\nimport { type TUnionEnum, UnionEnum } from '../schemas/union-enum.ts'\nimport { BaseType } from './base.ts'\n\nexport type AnyObjectEnumType<T extends { [K in string]: K } = any> =\n  ObjectEnumType<T, boolean, boolean, boolean>\nexport class ObjectEnumType<\n  T extends { [K in string]: K },\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TNativeEnum<T>, N, O, D> {\n  constructor(\n    readonly values: T,\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    values: T,\n  ): TNativeEnum<T> {\n    return NativeEnum(values, options)\n  }\n\n  nullable() {\n    return new ObjectEnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectEnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: keyof T) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: (keyof T)[]) {\n    return new ObjectEnumType(\n      this.values,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n\nexport type AnyEnumType = EnumType<any[], boolean, boolean, boolean>\nexport class EnumType<\n  T extends (string | number)[] = (string | number)[],\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<TUnionEnum<T>, N, O, D> {\n  constructor(\n    readonly values: [...T],\n    options: SchemaOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, values)\n  }\n\n  protected _constructSchema(\n    options: SchemaOptions,\n    values: [...T],\n  ): TUnionEnum<T> {\n    return UnionEnum(values, options)\n  }\n\n  nullable() {\n    return new EnumType(this.values, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new EnumType(this.values, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new EnumType(\n      this.values,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: T[number]) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new EnumType(\n      this.values,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(...examples: [T[number], ...T[number][]]) {\n    return new EnumType(this.values, ...this._with({ options: { examples } }))\n  }\n}\n"],"names":["NativeEnum","UnionEnum","BaseType","ObjectEnumType","constructor","values","options","isNullable","isOptional","hasDefault","_constructSchema","nullable","_with","optional","nullish","default","value","description","examples","EnumType"],"mappings":"AAEA,SAASA,UAAU,QAAQ,4BAA2B;AACtD,SAA0BC,SAAS,QAAQ,2BAA0B;AACrE,SAASC,QAAQ,QAAQ,YAAW;AAIpC,OAAO,MAAMC,uBAKHD;;IACRE,YACE,AAASC,MAAS,EAClBC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aAN1CA,SAAAA;IAOX;IAEUK,iBACRJ,OAAsB,EACtBD,MAAS,EACO;QAChB,OAAOL,WAAWK,QAAQC;IAC5B;IAEAK,WAAW;QACT,OAAO,IAAIR,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IAC1E;IAEAM,WAAW;QACT,OAAO,IAAIV,eAAe,IAAI,CAACE,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IAC1E;IAEAM,UAAU;QACR,OAAO,IAAIX,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAc,EAAE;QACtB,OAAO,IAAIb,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAId,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqB,EAAE;QACjC,OAAO,IAAIf,eACT,IAAI,CAACE,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IAE1C;AACF;AAGA,OAAO,MAAMC,iBAKHjB;;IACRE,YACE,AAASC,MAAc,EACvBC,UAAyB,CAAC,CAAC,EAC3BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,EAC1BC,aAAgB,KAAU,CAC1B;QACA,KAAK,CAACH,SAASC,YAAYC,YAAYC,YAAYJ;aAN1CA,SAAAA;IAOX;IAEUK,iBACRJ,OAAsB,EACtBD,MAAc,EACC;QACf,OAAOJ,UAAUI,QAAQC;IAC3B;IAEAK,WAAW;QACT,OAAO,IAAIQ,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;QAAK;IACpE;IAEAM,WAAW;QACT,OAAO,IAAIM,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEJ,YAAY;QAAK;IACpE;IAEAM,UAAU;QACR,OAAO,IAAIK,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEL,YAAY;YAAMC,YAAY;QAAK;IAEvD;IAEAO,QAAQC,KAAgB,EAAE;QACxB,OAAO,IAAIG,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAES,SAASC;YAAM;YAAGP,YAAY;QAAK;IAElE;IAEAQ,YAAYA,WAAmB,EAAE;QAC/B,OAAO,IAAIE,SACT,IAAI,CAACd,MAAM,KACR,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEW;YAAY;QAAE;IAE7C;IAEAC,SAAS,GAAGA,QAAqC,EAAE;QACjD,OAAO,IAAIC,SAAS,IAAI,CAACd,MAAM,KAAK,IAAI,CAACO,KAAK,CAAC;YAAEN,SAAS;gBAAEY;YAAS;QAAE;IACzE;AACF"}

package/dist/types/object.js

@@ -1,6 +1,6 @@
 import { Type } from '@sinclair/typebox';
 import { BaseType, getTypeSchema } from "./base.js";
-import { EnumType } from "./enum.js";
+import { EnumType, ObjectEnumType } from "./enum.js";
 export class ObjectType extends BaseType {
     properties;
     constructor(properties = {}, options = {}, isNullable = false, isOptional = false, hasDefault = false){
@@ -97,7 +97,15 @@ export class RecordType extends BaseType {
         this.element = element;
     }
     _constructSchema(options, key, element) {
-        return Type.Record(getTypeSchema(key), getTypeSchema(element), options);
+        let keySchema;
+        if (key instanceof EnumType) {
+            keySchema = Type.Union(key.values.map((value)=>Type.Literal(value)));
+        } else if (key instanceof ObjectEnumType) {
+            keySchema = Type.Union(Object.values(key.values).map((value)=>Type.Literal(value)));
+        } else {
+            keySchema = getTypeSchema(key);
+        }
+        return Type.Record(keySchema, getTypeSchema(element), options);
     }
     nullable() {
         return new RecordType(this.key, this.element, ...this._with({

package/dist/types/object.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecord,\n  Type,\n} from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\nimport { type AnyEnumType, type AnyObjectEnumType, EnumType } from './enum.ts'\nimport type { AnyLiteralType } from './literal.ts'\nimport type { AnyStringType } from './string.ts'\nimport type { AnyUnionType } from './union.ts'\n\nexport class ObjectType<\n  T extends Record<string, BaseType>,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    protected readonly properties: T = {} as T,\n    options: ObjectOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, properties)\n  }\n\n  protected _constructSchema(\n    options: ObjectOptions,\n    properties: T,\n  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K][typeStatic]['schema']\n    }\n\n    for (const [key, value] of Object.entries(properties)) {\n      // @ts-expect-error\n      schemaProperties[key] = getTypeSchema(value)\n    }\n    return Type.Object(schemaProperties, options)\n  }\n\n  nullable() {\n    return new ObjectType(this.properties, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectType(this.properties, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { examples } }),\n    )\n  }\n\n  pick<P extends { [K in keyof T]?: true }>(pick: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => pick[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Pick<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  omit<P extends { [K in keyof T]?: true }>(omit: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => !omit[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Omit<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  extend<P extends Record<string, BaseType>>(properties: P) {\n    const [_, ...args] = this._with()\n    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)\n  }\n\n  merge<T extends ObjectType<Record<string, BaseType>>>(object: T) {\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      { ...this.properties, ...object.properties },\n      {},\n      ...args,\n    )\n  }\n\n  partial() {\n    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =\n      {} as any\n    for (const [key, value] of Object.entries(this.properties)) {\n      // @ts-expect-error\n      properties[key] = value.optional()\n    }\n    const [_, ...args] = this._with()\n    return new ObjectType(properties, {}, ...args)\n  }\n\n  keyof(): EnumType<UnionToTupleString<keyof T>> {\n    return new EnumType(Object.keys(this.properties) as any)\n  }\n}\n\nexport class RecordType<\n  K extends\n    | AnyLiteralType\n    | AnyEnumType\n    | AnyObjectEnumType\n    | AnyStringType\n    | AnyUnionType,\n  E extends BaseType,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>,\n  N,\n  O,\n  D,\n  ObjectOptions\n> {\n  constructor(\n    protected readonly key: K,\n    protected readonly element: E,\n    options: ObjectOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, key, element)\n  }\n\n  protected _constructSchema(options: ObjectOptions, key: K, element: E) {\n    return Type.Record(\n      getTypeSchema(key),\n      getTypeSchema(element),\n      options,\n    ) as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>\n  }\n\n  nullable() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true }),\n    )\n  }\n\n  optional() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isOptional: true }),\n    )\n  }\n\n  nullish() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","EnumType","ObjectType","constructor","properties","options","isNullable","isOptional","hasDefault","_constructSchema","schemaProperties","key","value","Object","entries","nullable","_with","optional","nullish","default","description","examples","pick","fromEntries","filter","_","args","omit","extend","merge","object","partial","keyof","keys","RecordType","element","Record"],"mappings":"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"}
+{"version":3,"sources":["../../../src/types/object.ts"],"sourcesContent":["import {\n  type ObjectOptions,\n  type TObject,\n  type TRecord,\n  type TSchema,\n  Type,\n} from '@sinclair/typebox'\nimport type { typeStatic } from '../constants.ts'\nimport type { UnionToTupleString } from '../utils.ts'\nimport { BaseType, getTypeSchema } from './base.ts'\nimport {\n  type AnyEnumType,\n  type AnyObjectEnumType,\n  EnumType,\n  ObjectEnumType,\n} from './enum.ts'\nimport type { AnyLiteralType } from './literal.ts'\nimport type { AnyStringType } from './string.ts'\nimport type { AnyUnionType } from './union.ts'\n\nexport class ObjectType<\n  T extends Record<string, BaseType>,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }>,\n  N,\n  O,\n  D\n> {\n  constructor(\n    protected readonly properties: T = {} as T,\n    options: ObjectOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, properties)\n  }\n\n  protected _constructSchema(\n    options: ObjectOptions,\n    properties: T,\n  ): TObject<{ [K in keyof T]: T[K][typeStatic]['schema'] }> {\n    const schemaProperties = {} as {\n      [K in keyof T]: T[K][typeStatic]['schema']\n    }\n\n    for (const [key, value] of Object.entries(properties)) {\n      // @ts-expect-error\n      schemaProperties[key] = getTypeSchema(value)\n    }\n    return Type.Object(schemaProperties, options)\n  }\n\n  nullable() {\n    return new ObjectType(this.properties, ...this._with({ isNullable: true }))\n  }\n\n  optional() {\n    return new ObjectType(this.properties, ...this._with({ isOptional: true }))\n  }\n\n  nullish() {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new ObjectType(\n      this.properties,\n      ...this._with({ options: { examples } }),\n    )\n  }\n\n  pick<P extends { [K in keyof T]?: true }>(pick: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => pick[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Pick<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  omit<P extends { [K in keyof T]?: true }>(omit: P) {\n    const properties = Object.fromEntries(\n      Object.entries(this.properties).filter(([key]) => !omit[key]),\n    )\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      properties as Omit<T, Extract<keyof P, keyof T>>,\n      {},\n      ...args,\n    )\n  }\n\n  extend<P extends Record<string, BaseType>>(properties: P) {\n    const [_, ...args] = this._with()\n    return new ObjectType({ ...this.properties, ...properties }, {}, ...args)\n  }\n\n  merge<T extends ObjectType<Record<string, BaseType>>>(object: T) {\n    const [_, ...args] = this._with()\n    return new ObjectType(\n      { ...this.properties, ...object.properties },\n      {},\n      ...args,\n    )\n  }\n\n  partial() {\n    const properties: { [K in keyof T]: ReturnType<T[K]['optional']> } =\n      {} as any\n    for (const [key, value] of Object.entries(this.properties)) {\n      // @ts-expect-error\n      properties[key] = value.optional()\n    }\n    const [_, ...args] = this._with()\n    return new ObjectType(properties, {}, ...args)\n  }\n\n  keyof(): EnumType<UnionToTupleString<keyof T>> {\n    return new EnumType(Object.keys(this.properties) as any)\n  }\n}\n\nexport class RecordType<\n  K extends\n    | AnyLiteralType\n    | AnyEnumType\n    | AnyObjectEnumType\n    | AnyStringType\n    | AnyUnionType,\n  E extends BaseType,\n  N extends boolean = false,\n  O extends boolean = false,\n  D extends boolean = false,\n> extends BaseType<\n  TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>,\n  N,\n  O,\n  D,\n  ObjectOptions\n> {\n  constructor(\n    protected readonly key: K,\n    protected readonly element: E,\n    options: ObjectOptions = {},\n    isNullable: N = false as N,\n    isOptional: O = false as O,\n    hasDefault: D = false as D,\n  ) {\n    super(options, isNullable, isOptional, hasDefault, key, element)\n  }\n\n  protected _constructSchema(options: ObjectOptions, key: K, element: E) {\n    let keySchema: TSchema\n\n    if (key instanceof EnumType) {\n      keySchema = Type.Union(key.values.map((value) => Type.Literal(value)))\n    } else if (key instanceof ObjectEnumType) {\n      keySchema = Type.Union(\n        Object.values(key.values).map((value) => Type.Literal(value as string)),\n      )\n    } else {\n      keySchema = getTypeSchema(key)\n    }\n\n    return Type.Record(\n      keySchema,\n      getTypeSchema(element),\n      options,\n    ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>\n  }\n\n  nullable() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true }),\n    )\n  }\n\n  optional() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isOptional: true }),\n    )\n  }\n\n  nullish() {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ isNullable: true, isOptional: true }),\n    )\n  }\n\n  default(value: this[typeStatic]['encoded']) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { default: value }, hasDefault: true }),\n    )\n  }\n\n  description(description: string) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { description } }),\n    )\n  }\n\n  examples(\n    ...examples: [this[typeStatic]['encoded'], ...this[typeStatic]['encoded'][]]\n  ) {\n    return new RecordType(\n      this.key,\n      this.element,\n      ...this._with({ options: { examples } }),\n    )\n  }\n}\n"],"names":["Type","BaseType","getTypeSchema","EnumType","ObjectEnumType","ObjectType","constructor","properties","options","isNullable","isOptional","hasDefault","_constructSchema","schemaProperties","key","value","Object","entries","nullable","_with","optional","nullish","default","description","examples","pick","fromEntries","filter","_","args","omit","extend","merge","object","partial","keyof","keys","RecordType","element","keySchema","Union","values","map","Literal","Record"],"mappings":"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"}

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "@sinclair/typebox": "^0.33.7",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.3.10"
+    "@nmtjs/common": "0.4.0"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.33.7",
     "temporal-polyfill": "^0.2.5",
-    "@nmtjs/common": "0.3.10"
+    "@nmtjs/common": "0.4.0"
   },
   "files": [
     "src",
@@ -35,7 +35,7 @@
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.3.10",
+  "version": "0.4.0",
   "scripts": {
     "build": "neemata-build -p neutral --root=./src './**/*.ts'",
     "type-check": "tsc --noEmit"

package/src/compiler.ts

@@ -1,64 +1,75 @@
+import type { TSchema } from '@sinclair/typebox'
 import {
   TypeCompiler,
   type ValueErrorIterator,
 } from '@sinclair/typebox/compiler'
 import { Value } from '@sinclair/typebox/value'
+import type { typeStatic } from './constants.ts'
 import { type BaseType, getTypeSchema } from './types/base.ts'
 
-export type Compiled = {
+export type Compiled<T extends BaseType = BaseType> = {
   check: (val: unknown) => boolean
   errors: (val: unknown) => ValueErrorIterator
   prepare: (val: unknown) => unknown
   convert: (val: unknown) => unknown
-  decode: (
+  decode: (val: unknown) => T[typeStatic]['decoded']
+  encode: (val: unknown) => T[typeStatic]['encoded']
+  decodeSafe: (
     val: unknown,
-  ) => { success: true; value: unknown } | { success: false; error: any }
-  encode: (
+  ) =>
+    | { success: true; value: T[typeStatic]['decoded'] }
+    | { success: false; error: any }
+  encodeSafe: (
     val: unknown,
-  ) => { success: true; value: unknown } | { success: false; error: any }
+  ) =>
+    | { success: true; value: T[typeStatic]['encoded'] }
+    | { success: false; error: any }
 }
 
-const compileType = (type: BaseType) => {
+function _prepare(schema: TSchema, value: any) {
+  return Value.Default(schema, Value.Clean(schema, value))
+}
+
+function _convert(schema: TSchema, value: any) {
+  return Value.Convert(schema, value)
+}
+
+function compileType(type: BaseType) {
   const schema = getTypeSchema(type)
   const compiled = TypeCompiler.Compile(schema)
-  const prepare = (value: any) => {
-    for (const fn of [Value.Clean, Value.Default]) {
-      value = fn(schema, value)
-    }
-    return value
-  }
-  const convert = (value: any) => Value.Convert(schema, value)
   return {
     check: compiled.Check.bind(compiled),
     errors: compiled.Errors.bind(compiled),
     decode: compiled.Decode.bind(compiled),
     encode: compiled.Encode.bind(compiled),
-    prepare,
-    convert,
+    prepare: _prepare.bind(null, schema),
+    convert: _convert.bind(null, schema),
   }
 }
 
-export const compile = (schema: BaseType): Compiled => {
+export function compile<T extends BaseType>(schema: T): Compiled<T> {
   const compiled = compileType(schema)
 
   // TODO: custom error handling/shaping
   return {
     ...compiled,
-    decode: (val) => {
+    decode: (val) => compiled.decode(val),
+    encode: (val) => compiled.encode(val),
+    decodeSafe: (val) => {
       try {
         return {
           success: true as const,
-          value: compiled.decode(compiled.prepare(val)),
+          value: compiled.decode(val),
         }
       } catch (error) {
         return { success: false as const, error }
       }
     },
-    encode: (val) => {
+    encodeSafe: (val) => {
       try {
         return {
           success: true as const,
-          value: compiled.encode(compiled.prepare(val)),
+          value: compiled.encode(val),
         }
       } catch (error) {
         return { success: false as const, error }
@@ -66,3 +77,35 @@ export const compile = (schema: BaseType): Compiled => {
     },
   }
 }
+
+export namespace runtime {
+  export function prepare(type: BaseType, value: any) {
+    return _prepare(getTypeSchema(type), value)
+  }
+
+  export function convert(type: BaseType, value: any) {
+    return _convert(getTypeSchema(type), value)
+  }
+
+  export function errors(type: BaseType, value: any): ValueErrorIterator {
+    return Value.Errors(getTypeSchema(type), value)
+  }
+
+  export function check(type: BaseType, value: any): boolean {
+    return Value.Check(getTypeSchema(type), value)
+  }
+
+  export function decode<T extends BaseType>(
+    type: BaseType,
+    value: any,
+  ): T[typeStatic]['decoded'] {
+    return Value.Decode(getTypeSchema(type), value)
+  }
+
+  export function encode<T extends BaseType>(
+    type: T,
+    value: any,
+  ): T[typeStatic]['encoded'] {
+    return Value.Encode(getTypeSchema(type), value)
+  }
+}

package/src/types/enum.ts

@@ -13,7 +13,7 @@ export class ObjectEnumType<
   D extends boolean = false,
 > extends BaseType<TNativeEnum<T>, N, O, D> {
   constructor(
-    protected readonly values: T,
+    readonly values: T,
     options: SchemaOptions = {},
     isNullable: N = false as N,
     isOptional: O = false as O,
@@ -74,7 +74,7 @@ export class EnumType<
   D extends boolean = false,
 > extends BaseType<TUnionEnum<T>, N, O, D> {
   constructor(
-    protected readonly values: [...T],
+    readonly values: [...T],
     options: SchemaOptions = {},
     isNullable: N = false as N,
     isOptional: O = false as O,

package/src/types/object.ts

@@ -2,12 +2,18 @@ import {
   type ObjectOptions,
   type TObject,
   type TRecord,
+  type TSchema,
   Type,
 } from '@sinclair/typebox'
 import type { typeStatic } from '../constants.ts'
 import type { UnionToTupleString } from '../utils.ts'
 import { BaseType, getTypeSchema } from './base.ts'
-import { type AnyEnumType, type AnyObjectEnumType, EnumType } from './enum.ts'
+import {
+  type AnyEnumType,
+  type AnyObjectEnumType,
+  EnumType,
+  ObjectEnumType,
+} from './enum.ts'
 import type { AnyLiteralType } from './literal.ts'
 import type { AnyStringType } from './string.ts'
 import type { AnyUnionType } from './union.ts'
@@ -170,11 +176,23 @@ export class RecordType<
   }
 
   protected _constructSchema(options: ObjectOptions, key: K, element: E) {
+    let keySchema: TSchema
+
+    if (key instanceof EnumType) {
+      keySchema = Type.Union(key.values.map((value) => Type.Literal(value)))
+    } else if (key instanceof ObjectEnumType) {
+      keySchema = Type.Union(
+        Object.values(key.values).map((value) => Type.Literal(value as string)),
+      )
+    } else {
+      keySchema = getTypeSchema(key)
+    }
+
     return Type.Record(
-      getTypeSchema(key),
+      keySchema,
       getTypeSchema(element),
       options,
-    ) as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>
+    ) as unknown as TRecord<K[typeStatic]['schema'], E[typeStatic]['schema']>
   }
 
   nullable() {