@nmtjs/type 0.3.11 → 0.4.1

package/dist/compiler.js

@@ -1,39 +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)=>compiled.decode(compiled.prepare(val)),
-        encode: (val)=>compiled.encode(compiled.prepare(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 {
@@ -46,7 +42,7 @@ export const compile = (schema)=>{
             try {
                 return {
                     success: true,
-                    value: compiled.encode(compiled.prepare(val))
+                    value: compiled.encode(val)
                 };
             } catch (error) {
                 return {
@@ -56,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: (val: unknown) => unknown\n  encode: (val: unknown) => unknown\n  decodeSafe: (\n    val: unknown,\n  ) => { success: true; value: unknown } | { success: false; error: any }\n  encodeSafe: (\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) => compiled.decode(compiled.prepare(val)),\n    encode: (val) => compiled.encode(compiled.prepare(val)),\n    decodeSafe: (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    encodeSafe: (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","decodeSafe","success","error","encodeSafe"],"mappings":"AAAA,SACEA,YAAY,QAEP,6BAA4B;AACnC,SAASC,KAAK,QAAQ,0BAAyB;AAC/C,SAAwBC,aAAa,QAAQ,kBAAiB;AAiB9D,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,MAAQnB,SAASc,MAAM,CAACd,SAASE,OAAO,CAACiB;QAClDH,QAAQ,CAACG,MAAQnB,SAASgB,MAAM,CAAChB,SAASE,OAAO,CAACiB;QAClDC,YAAY,CAACD;YACX,IAAI;gBACF,OAAO;oBACLE,SAAS;oBACTlB,OAAOH,SAASc,MAAM,CAACd,SAASE,OAAO,CAACiB;gBAC1C;YACF,EAAE,OAAOG,OAAO;gBACd,OAAO;oBAAED,SAAS;oBAAgBC;gBAAM;YAC1C;QACF;QACAC,YAAY,CAACJ;YACX,IAAI;gBACF,OAAO;oBACLE,SAAS;oBACTlB,OAAOH,SAASgB,MAAM,CAAChB,SAASE,OAAO,CAACiB;gBAC1C;YACF,EAAE,OAAOG,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/package.json

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

package/src/compiler.ts

@@ -1,58 +1,65 @@
+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: (val: unknown) => unknown
-  encode: (val: unknown) => unknown
+  decode: (val: unknown) => T[typeStatic]['decoded']
+  encode: (val: unknown) => T[typeStatic]['encoded']
   decodeSafe: (
     val: unknown,
-  ) => { success: true; value: unknown } | { success: false; error: any }
+  ) =>
+    | { 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) => compiled.decode(compiled.prepare(val)),
-    encode: (val) => compiled.encode(compiled.prepare(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 }
@@ -62,7 +69,7 @@ export const compile = (schema: BaseType): Compiled => {
       try {
         return {
           success: true as const,
-          value: compiled.encode(compiled.prepare(val)),
+          value: compiled.encode(val),
         }
       } catch (error) {
         return { success: false as const, error }
@@ -70,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)
+  }
+}