@mionjs/run-types 0.8.0-alpha.0

package/.dist/esm/src/constants.kind.js

@@ -0,0 +1,74 @@
+import { ReflectionKind } from "@deepkit/type";
+import { __ΩRunType as ___RunType } from "./types.js";
+const ReflectionKindName = {
+  0: "never",
+  1: "any",
+  2: "unknown",
+  3: "void",
+  4: "objectLiteral",
+  // name was changed from deepkit's 'object' to 'objectLiteral'
+  5: "string",
+  6: "number",
+  7: "boolean",
+  8: "symbol",
+  9: "bigint",
+  10: "null",
+  11: "undefined",
+  12: "regexp",
+  13: "literal",
+  14: "templateLiteral",
+  15: "property",
+  16: "method",
+  17: "function",
+  18: "parameter",
+  19: "promise",
+  20: "class",
+  21: "typeParameter",
+  22: "enum",
+  23: "union",
+  24: "intersection",
+  25: "array",
+  26: "tuple",
+  27: "tupleMember",
+  28: "enumMember",
+  29: "rest",
+  30: "object",
+  // name was changed from deepkit's 'objectLiteral' to 'object' for better error messages
+  31: "indexSignature",
+  32: "propertySignature",
+  33: "methodSignature",
+  34: "infer",
+  35: "callSignature"
+};
+const ReflectionSubKind = {
+  // group of sub-kinds that extends ReflectionKind.class
+  date: 2001,
+  map: 2002,
+  set: 2003,
+  nonSerializable: 2004,
+  params: 1701,
+  mapKey: 1801,
+  mapValue: 1802,
+  setItem: 1803
+};
+const ReflectionSubNames = {
+  2001: "date",
+  2002: "map",
+  2003: "set",
+  1701: "params"
+};
+const __ΩAnyKindName = [() => ReflectionKind, () => ReflectionSubKind, "AnyKindName", 'Pi!gi"gJw#y'];
+function getReflectionName(rt) {
+  if (rt.src.subKind)
+    return ReflectionSubNames[rt.src.subKind];
+  return ReflectionKindName[rt.src.kind];
+}
+getReflectionName.__type = [() => ___RunType, "rt", () => __ΩAnyKindName, "getReflectionName", 'Pn!2"n#/$'];
+export {
+  ReflectionKindName,
+  ReflectionSubKind,
+  ReflectionSubNames,
+  __ΩAnyKindName,
+  getReflectionName
+};
+//# sourceMappingURL=constants.kind.js.map

package/.dist/esm/src/constants.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.kind.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/createRunType.d.ts

@@ -0,0 +1,5 @@
+import { RunType } from './types.ts';
+import { ReceiveType } from '@deepkit/type';
+import { FunctionRunType } from './nodes/function/function.ts';
+export declare function runType<T>(type?: ReceiveType<T>): RunType;
+export declare function reflectFunction<Fn extends (...args: any[]) => any>(fn: Fn): FunctionRunType;

package/.dist/esm/src/createRunType.js

@@ -0,0 +1,284 @@
+import { reflect, resolveReceiveType, stringifyType, typeAnnotation, ReflectionKind, __ΩReceiveType as ___ReceiveType } from "@deepkit/type";
+import { hasType, hasReturn, hasIndexType, hasTypes, hasParameters, hasArguments, hasExtendsArguments, hasImplements, isNonSerializableObject, isNativeUtilityStringTypes, isNonSerializableClass } from "./lib/guards.js";
+import { StringRunType } from "./nodes/atomic/string.js";
+import { DateRunType } from "./nodes/atomic/date.js";
+import { NumberRunType } from "./nodes/atomic/number.js";
+import { BooleanRunType } from "./nodes/atomic/boolean.js";
+import { NullRunType } from "./nodes/atomic/null.js";
+import { BigIntRunType } from "./nodes/atomic/bigInt.js";
+import { AnyRunType } from "./nodes/atomic/any.js";
+import { UndefinedRunType } from "./nodes/atomic/undefined.js";
+import { UnknownRunType } from "./nodes/atomic/unknown.js";
+import { VoidRunType } from "./nodes/atomic/void.js";
+import { ArrayRunType } from "./nodes/member/array.js";
+import { LiteralRunType } from "./nodes/atomic/literal.js";
+import { RegexpRunType } from "./nodes/atomic/regexp.js";
+import { NeverRunType } from "./nodes/atomic/never.js";
+import { EnumRunType } from "./nodes/atomic/enum.js";
+import { EnumMemberRunType } from "./nodes/atomic/enumMember.js";
+import { UnionRunType } from "./nodes/collection/union.js";
+import { TupleRunType } from "./nodes/collection/tuple.js";
+import { FunctionParamsRunType } from "./nodes/collection/functionParams.js";
+import { TupleMemberRunType } from "./nodes/member/tupleMember.js";
+import { InterfaceRunType } from "./nodes/collection/interface.js";
+import { PropertyRunType } from "./nodes/member/property.js";
+import { IndexSignatureRunType } from "./nodes/member/indexProperty.js";
+import { MethodSignatureRunType } from "./nodes/member/methodSignature.js";
+import { CallSignatureRunType } from "./nodes/member/callSignature.js";
+import { FunctionRunType } from "./nodes/function/function.js";
+import { PromiseRunType } from "./nodes/native/promise.js";
+import { ObjectRunType } from "./nodes/atomic/object.js";
+import { IntersectionRunType } from "./nodes/collection/intersection.js";
+import { ParameterRunType } from "./nodes/member/param.js";
+import { MethodRunType } from "./nodes/member/method.js";
+import { RestParamsRunType } from "./nodes/member/restParams.js";
+import { ClassRunType } from "./nodes/collection/class.js";
+import { MapRunType } from "./nodes/native/map.js";
+import { ReflectionSubKind } from "./constants.kind.js";
+import { SetRunType } from "./nodes/native/set.js";
+import { SymbolRunType } from "./nodes/atomic/symbol.js";
+import { NonSerializableRunType } from "./nodes/native/nonSerializable.js";
+import { registerErrorDeserializers } from "@mionjs/core";
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+function runType(type = runType.Ω?.[0]) {
+  runType.Ω = void 0;
+  const start = Date.now();
+  const src = resolveReceiveType(type);
+  const took0 = Date.now() - start;
+  createRunTypes(src);
+  const took1 = Date.now() - start;
+  const diff = took1 - took0;
+  if (diff > 60)
+    console.warn(`RunType overhead is very long: ${diff}ms for ${stringifyType(src)}`);
+  return src._rt;
+}
+runType.__type = [() => ___ReceiveType, "type", "RunType", "runType", 'P"o!"2"8"w#/$'];
+function reflectFunction(fn) {
+  const src = reflect(fn);
+  runType(src);
+  return src._rt;
+}
+reflectFunction.__type = ["fn", () => FunctionRunType, "reflectFunction", 'P"2!P7"/#'];
+function createRunTypes(src) {
+  registerErrorDeserializers();
+  const stack = [src];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || current._rt)
+      continue;
+    try {
+      createRunType(current);
+    } catch (error) {
+      const typesStackMessage = "\nTypes Stack: " + stack.map(__assignType((t) => t.typeName || t.kind, ["t", "", 'P"2!"/"'])).join(", ");
+      error.message += typesStackMessage;
+      throw error;
+    }
+    if (hasType(current))
+      stack.push(current.type);
+    if (hasReturn(current))
+      stack.push(current.return);
+    if (hasIndexType(current))
+      stack.push(current.indexType);
+    if (current.origin)
+      stack.push(current.origin);
+    if (current.indexAccessOrigin?.index)
+      stack.push(current.indexAccessOrigin?.index);
+    if (current.indexAccessOrigin?.container)
+      stack.push(current.indexAccessOrigin?.container);
+    if (hasTypes(current))
+      pushToStack(current.types, stack);
+    if (hasParameters(current))
+      pushToStack(current.parameters, stack);
+    if (hasArguments(current))
+      pushToStack(current.arguments, stack);
+    if (hasExtendsArguments(current))
+      pushToStack(current.extendsArguments, stack);
+    if (hasImplements(current))
+      pushToStack(current.implements, stack);
+    if (current.typeArguments)
+      pushToStack(current.typeArguments, stack);
+    if (current.decorators)
+      pushToStack(current.decorators, stack);
+    if (current.scheduleDecorators)
+      pushToStack(current.scheduleDecorators, stack);
+    if (current.annotations) {
+      const annotations = typeAnnotation.getAnnotations(current);
+      for (const annotation of annotations)
+        stack.push(annotation.options);
+    }
+    current.originTypes?.forEach(__assignType((ot) => {
+      if (ot.typeArguments)
+        pushToStack(ot.typeArguments, stack);
+    }, ["ot", "", 'P"2!"/"']));
+    if (current.parent && !current.parent?._rt)
+      stack.push(current.parent);
+  }
+}
+createRunTypes.__type = ["SrcType", "src", "createRunTypes", 'P"w!2"$/#'];
+function pushToStack(subTypes, stack) {
+  if (Array.isArray(subTypes))
+    stack.push(...subTypes);
+}
+pushToStack.__type = ["Type", "subTypes", "stack", "pushToStack", 'P"w!F2""w!F2#"/$'];
+function createRunType(deepkitType) {
+  const existingType = deepkitType._rt;
+  if (existingType)
+    return existingType;
+  let rt;
+  switch (deepkitType.kind) {
+    // ###################### ATOMIC RUNTYPES ######################
+    // Primitive types and other atomic types that don't contain other types
+    case ReflectionKind.any:
+      rt = new AnyRunType();
+      break;
+    case ReflectionKind.bigint:
+      rt = new BigIntRunType();
+      break;
+    case ReflectionKind.boolean:
+      rt = new BooleanRunType();
+      break;
+    case ReflectionKind.enum:
+      rt = new EnumRunType();
+      break;
+    case ReflectionKind.enumMember:
+      rt = new EnumMemberRunType();
+      break;
+    case ReflectionKind.literal:
+      rt = new LiteralRunType();
+      break;
+    case ReflectionKind.never:
+      rt = isNativeUtilityStringTypes(deepkitType) ? new StringRunType() : new NeverRunType();
+      break;
+    case ReflectionKind.null:
+      rt = new NullRunType();
+      break;
+    case ReflectionKind.number:
+      rt = new NumberRunType();
+      break;
+    case ReflectionKind.object:
+      rt = new ObjectRunType();
+      break;
+    case ReflectionKind.regexp:
+      rt = new RegexpRunType();
+      break;
+    case ReflectionKind.string:
+      rt = new StringRunType();
+      break;
+    case ReflectionKind.symbol:
+      rt = new SymbolRunType();
+      break;
+    case ReflectionKind.templateLiteral:
+      throw new Error("Template Literals are resolved by the compiler to Literals ie: const tl = `${string}World`. Template literal types are not supported. ie type TL = `${string}World`");
+    case ReflectionKind.undefined:
+      rt = new UndefinedRunType();
+      break;
+    case ReflectionKind.unknown:
+      rt = new UnknownRunType();
+      break;
+    case ReflectionKind.void:
+      rt = new VoidRunType();
+      break;
+    // ###################### MEMBER RUNTYPES ######################
+    // Types that represent members of collections or other structures
+    case ReflectionKind.array:
+      rt = new ArrayRunType();
+      break;
+    case ReflectionKind.callSignature:
+      rt = new CallSignatureRunType();
+      break;
+    case ReflectionKind.function:
+      if (deepkitType.subKind === ReflectionSubKind.params) {
+        rt = new FunctionParamsRunType();
+      } else {
+        const frt = new FunctionRunType();
+        frt.parameterRunTypes.src = deepkitType;
+        rt = frt;
+      }
+      break;
+    case ReflectionKind.indexSignature:
+      rt = new IndexSignatureRunType();
+      break;
+    case ReflectionKind.method:
+      rt = new MethodRunType();
+      break;
+    case ReflectionKind.methodSignature:
+      rt = new MethodSignatureRunType();
+      break;
+    case ReflectionKind.parameter:
+      rt = new ParameterRunType();
+      break;
+    case ReflectionKind.property:
+    case ReflectionKind.propertySignature:
+      rt = new PropertyRunType();
+      break;
+    case ReflectionKind.rest:
+      rt = new RestParamsRunType();
+      break;
+    case ReflectionKind.tupleMember:
+      rt = new TupleMemberRunType();
+      break;
+    case ReflectionKind.promise:
+      rt = new PromiseRunType();
+      break;
+    // ###################### COLLECTION RUNTYPES ######################
+    case ReflectionKind.objectLiteral:
+      if (isNonSerializableObject(deepkitType)) {
+        rt = new NonSerializableRunType();
+      } else {
+        rt = new InterfaceRunType();
+      }
+      break;
+    case ReflectionKind.class:
+      rt = initClassRunType(deepkitType);
+      break;
+    // Types that contain other types as members
+    case ReflectionKind.infer:
+      throw new Error("Infer type not supported, ie: type MyType =Type<T> = T extends (...args: any[]) => infer R ? R : any; https://www.typescriptlang.org/docs/handbook/2/conditional-types.html");
+    case ReflectionKind.intersection:
+      rt = new IntersectionRunType();
+      break;
+    case ReflectionKind.tuple:
+      rt = new TupleRunType();
+      break;
+    case ReflectionKind.typeParameter:
+      throw new Error('TypeParameter not implemented. Type parameters are the generic placeholders in type definitions (e.g., T in Array<T>, ErrType in TypedError<ErrType>). Type parameters are typically resolved during type instantiation and should not appear in runtime type checking.This error is typically caused by a generic type missing type arguments, e.g.: TypedError instead of TypedError<"my-error">.');
+    // rType = resolveTypeParameter(deepkitType, opts, mapper);
+    case ReflectionKind.union:
+      rt = new UnionRunType();
+      break;
+    default:
+      rt = new AnyRunType();
+      break;
+  }
+  rt.onCreated(deepkitType);
+  return rt;
+}
+createRunType.__type = ["Mutable", "deepkitType", "RunType", "createRunType", 'P"w!2""w#/$'];
+function initClassRunType(src) {
+  switch (src.classType) {
+    case Date:
+      src.subKind = ReflectionSubKind.date;
+      return new DateRunType();
+    case Map:
+      src.subKind = ReflectionSubKind.map;
+      return new MapRunType();
+    case Set:
+      src.subKind = ReflectionSubKind.set;
+      return new SetRunType();
+    default:
+      if (isNonSerializableClass(src)) {
+        src.subKind = ReflectionSubKind.nonSerializable;
+        return new NonSerializableRunType();
+      }
+      return new ClassRunType();
+  }
+}
+initClassRunType.__type = ["TypeClass", "subKind", "src", "BaseRunType", "initClassRunType", `PP"w!P'4"8MK2#"w$/%`];
+export {
+  reflectFunction,
+  runType
+};
+//# sourceMappingURL=createRunType.js.map

package/.dist/esm/src/createRunType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRunType.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/createRunTypeFunctions.d.ts

@@ -0,0 +1,12 @@
+import { ReceiveType } from '@deepkit/type';
+import { RunTypeOptions } from './types.ts';
+import { FromBinaryFn, IsTypeFn, JsonStringifyFn, PrepareForJsonFn, RestoreFromJsonFn, ToBinaryFn, ToCodeFn, TypeErrorsFn } from '@mionjs/core';
+export declare function createIsTypeFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<IsTypeFn>;
+export declare function createTypeErrorsFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<TypeErrorsFn>;
+export declare function createPrepareForJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<PrepareForJsonFn>;
+export declare function createRestoreFromJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<RestoreFromJsonFn>;
+export declare function createStringifyJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<JsonStringifyFn>;
+export declare function createToBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<ToBinaryFn>;
+export declare function createFromBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<FromBinaryFn>;
+export declare function createToJavascriptFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): ToCodeFn;
+export declare function createMockTypeFn<T>(type?: ReceiveType<T>): Promise<(opts?: Partial<RunTypeOptions>) => T>;

package/.dist/esm/src/createRunTypeFunctions.js

@@ -0,0 +1,78 @@
+import { JitFunctions } from "./constants.functions.js";
+import { __ΩReceiveType as ___ReceiveType } from "@deepkit/type";
+import { runType } from "./createRunType.js";
+import { __ΩRunTypeOptions as ___RunTypeOptions } from "./types.js";
+import { __ΩIsTypeFn as ___IsTypeFn, __ΩTypeErrorsFn as ___TypeErrorsFn, __ΩPrepareForJsonFn as ___PrepareForJsonFn, __ΩRestoreFromJsonFn as ___RestoreFromJsonFn, __ΩJsonStringifyFn as ___JsonStringifyFn, __ΩToBinaryFn as ___ToBinaryFn, __ΩFromBinaryFn as ___FromBinaryFn, __ΩToCodeFn as ___ToCodeFn } from "@mionjs/core";
+import { registerJitFunctionCompiler } from "./lib/jitFnsRegistry.js";
+const __ΩPartial = ["T", "Partial", 'l+e#!e"!fRb!Pde"!gN#"w"y'];
+function __assignType(fn, args) {
+  fn.__type = args;
+  return fn;
+}
+async function createIsTypeFn(opts, type = createIsTypeFn.Ω?.[0]) {
+  createIsTypeFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.isType, opts);
+}
+createIsTypeFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___IsTypeFn, "createIsTypeFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createTypeErrorsFn(opts, type = createTypeErrorsFn.Ω?.[0]) {
+  createTypeErrorsFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.typeErrors, opts);
+}
+createTypeErrorsFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___TypeErrorsFn, "createTypeErrorsFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createPrepareForJsonFn(opts, type = createPrepareForJsonFn.Ω?.[0]) {
+  createPrepareForJsonFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.prepareForJson, opts);
+}
+createPrepareForJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___PrepareForJsonFn, "createPrepareForJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createRestoreFromJsonFn(opts, type = createRestoreFromJsonFn.Ω?.[0]) {
+  createRestoreFromJsonFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.restoreFromJson, opts);
+}
+createRestoreFromJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___RestoreFromJsonFn, "createRestoreFromJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createStringifyJsonFn(opts, type = createStringifyJsonFn.Ω?.[0]) {
+  createStringifyJsonFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.stringifyJson, opts);
+}
+createStringifyJsonFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___JsonStringifyFn, "createStringifyJsonFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createToBinaryFn(opts, type = createToBinaryFn.Ω?.[0]) {
+  createToBinaryFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.toBinary, opts);
+}
+createToBinaryFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___ToBinaryFn, "createToBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
+async function createFromBinaryFn(opts, type = createFromBinaryFn.Ω?.[0]) {
+  createFromBinaryFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.fromBinary, opts);
+}
+createFromBinaryFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___FromBinaryFn, "createFromBinaryFn", 'Pn!2"8"o#"2$8n%`/&'];
+function createToJavascriptFn(opts, type = createToJavascriptFn.Ω?.[0]) {
+  createToJavascriptFn.Ω = void 0;
+  const rt = runType(type);
+  return rt.createJitFunction(JitFunctions.toJSCode, opts);
+}
+createToJavascriptFn.__type = [() => ___RunTypeOptions, "opts", () => ___ReceiveType, "type", () => ___ToCodeFn, "createToJavascriptFn", 'Pn!2"8"o#"2$8n%/&'];
+async function createMockTypeFn(type = createMockTypeFn.Ω?.[0]) {
+  createMockTypeFn.Ω = void 0;
+  const rt = runType(type);
+  await registerJitFunctionCompiler(JitFunctions.mock);
+  return __assignType((opts) => rt.mockType(opts), [() => __ΩPartial, () => ___RunTypeOptions, "opts", "", 'Pn"o!"2#8"/$']);
+}
+createMockTypeFn.__type = [() => ___ReceiveType, "type", () => __ΩPartial, () => ___RunTypeOptions, "opts", "", "createMockTypeFn", 'P"o!"2"8Pn$o#"2%8"/&`/\''];
+export {
+  createFromBinaryFn,
+  createIsTypeFn,
+  createMockTypeFn,
+  createPrepareForJsonFn,
+  createRestoreFromJsonFn,
+  createStringifyJsonFn,
+  createToBinaryFn,
+  createToJavascriptFn,
+  createTypeErrorsFn
+};
+//# sourceMappingURL=createRunTypeFunctions.js.map

package/.dist/esm/src/createRunTypeFunctions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRunTypeFunctions.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/.dist/esm/src/formats.runtype.d.ts

@@ -0,0 +1,6 @@
+import { TypeAnnotation } from '@deepkit/core';
+import { TypeFormatParams, Brand, TypeFormatPrimitives } from '@mionjs/core';
+export type TypeFormat<BaseType extends TypeFormatPrimitives, Name extends string, P extends TypeFormatParams, BrandName extends string = never> = [BrandName] extends [never] ? BaseType & TypeAnnotation<Name, P> : Brand<BaseType, BrandName> & TypeAnnotation<Name, P & {
+    brand: BrandName;
+}>;
+export declare type __ΩTypeFormat = any[];

package/.dist/esm/src/formats.runtype.js

@@ -0,0 +1,7 @@
+import { __ΩTypeAnnotation as ___TypeAnnotation } from "@deepkit/core";
+import { __ΩBrand as ___Brand } from "@mionjs/core";
+const __ΩTypeFormat = ["BaseType", "Name", "P", "BrandName", () => ___TypeAnnotation, () => ___Brand, () => ___TypeAnnotation, "brand", "TypeFormat", `lPPe$!e$"e$#o%#KRPe$!e$$o&#e$"Pe%#Pe&$4(MKo'#KRb!b"b#!c$PPe#$GP!Gqk#2Qw)y`];
+export {
+  __ΩTypeFormat
+};
+//# sourceMappingURL=formats.runtype.js.map

package/.dist/esm/src/formats.runtype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.runtype.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/.dist/esm/src/jitCompilers/binary/binarySpec/binaryHelpers.d.ts

@@ -0,0 +1,30 @@
+import { FunctionRunType } from '../../../nodes/function/function.ts';
+import { DataViewDeserializer, DataViewSerializer, StrictArrayBuffer } from '@mionjs/core';
+import { InterfaceRunType } from '../../../nodes/collection/interface.ts';
+import { RunType } from '../../../types.ts';
+export declare const serContext: DataViewSerializer;
+export declare const desContext: DataViewDeserializer;
+export declare function createSerializationFns(rt: RunType): {
+    serialize: (v: any) => StrictArrayBuffer;
+    deserialize: (data: StrictArrayBuffer) => any;
+};
+export declare function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number): {
+    serialize: (v: any) => StrictArrayBuffer;
+    deserialize: (data: StrictArrayBuffer) => any;
+};
+export declare function createSerializationReturnFn(rt: FunctionRunType): {
+    serialize: (v: any) => StrictArrayBuffer;
+    deserialize: (data: StrictArrayBuffer) => any;
+};
+export declare function createSerializationCallSignatureParamsFn(rt: InterfaceRunType): {
+    serialize: (v: any) => StrictArrayBuffer;
+    deserialize: (data: StrictArrayBuffer) => any;
+};
+export declare function createSerializationCallSignatureReturnFn(rt: InterfaceRunType): {
+    serialize: (v: any) => StrictArrayBuffer;
+    deserialize: (data: StrictArrayBuffer) => any;
+};
+export declare function roundTrip(serialize: (v: any) => StrictArrayBuffer, deserialize: (v: StrictArrayBuffer) => any, value: any): {
+    serialized: StrictArrayBuffer;
+    deserialized: any;
+};

package/.dist/esm/src/jitCompilers/binary/binarySpec/binaryHelpers.js

@@ -0,0 +1,109 @@
+import { JitFunctions } from "../../../constants.functions.js";
+import { getENV, setSerializationOptions, createDataViewSerializer, createDataViewDeserializer } from "@mionjs/core";
+import { afterAll, expect } from "vitest";
+const DEBUG = getENV("DEBUG_JIT") === "print";
+const toJsonSerializers = /* @__PURE__ */ new Map();
+setSerializationOptions({ bufferSize: 1024 });
+const serContext = createDataViewSerializer("test");
+const desContext = createDataViewDeserializer("test", new ArrayBuffer(0));
+const SERIALIZE_FN = JitFunctions.toBinary;
+const DESERIALIZE_FN = JitFunctions.fromBinary;
+function createSerializationFns(rt) {
+  const toBinary = rt.createJitFunction(SERIALIZE_FN);
+  const fromBinary = rt.createJitFunction(DESERIALIZE_FN);
+  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
+  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
+  if (DEBUG) {
+    const toJson = rt.createJitFunction(JitFunctions.prepareForJson);
+    const stringify = (v) => JSON.stringify(toJson(v));
+    toJsonSerializers.set(serialize, stringify);
+  }
+  return { serialize, deserialize };
+}
+function createSerializationParamsFn(rt, sliceStart) {
+  const params = typeof sliceStart === "number" ? { paramsSlice: { start: sliceStart } } : void 0;
+  const toBinary = rt.createJitParamsFunction(SERIALIZE_FN, params);
+  const fromBinary = rt.createJitParamsFunction(DESERIALIZE_FN, params);
+  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
+  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
+  if (DEBUG) {
+    const toJson = rt.createJitParamsFunction(JitFunctions.prepareForJson, params);
+    const stringify = (v) => JSON.stringify(toJson(v));
+    toJsonSerializers.set(serialize, stringify);
+  }
+  return { serialize, deserialize };
+}
+function createSerializationReturnFn(rt) {
+  const toBinary = rt.createJitReturnFunction(SERIALIZE_FN);
+  const fromBinary = rt.createJitReturnFunction(DESERIALIZE_FN);
+  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
+  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
+  if (DEBUG) {
+    const toJson = rt.createJitReturnFunction(JitFunctions.prepareForJson);
+    const stringify = (v) => JSON.stringify(toJson(v));
+    toJsonSerializers.set(serialize, stringify);
+  }
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureParamsFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const toBinary = callSignature.createJitParamsFunction(SERIALIZE_FN);
+  const fromBinary = callSignature.createJitParamsFunction(DESERIALIZE_FN);
+  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
+  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
+  if (DEBUG) {
+    const toJson = callSignature.createJitParamsFunction(JitFunctions.prepareForJson);
+    const stringify = (v) => JSON.stringify(toJson(v));
+    toJsonSerializers.set(serialize, stringify);
+  }
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureReturnFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const toBinary = callSignature.createJitReturnFunction(SERIALIZE_FN);
+  const fromBinary = callSignature.createJitReturnFunction(DESERIALIZE_FN);
+  const serialize = (v) => (toBinary(v, serContext), serContext.getBuffer());
+  const deserialize = (data) => (desContext.setBuffer(data), fromBinary(void 0, desContext));
+  if (DEBUG) {
+    const toJson = callSignature.createJitReturnFunction(JitFunctions.prepareForJson);
+    const stringify = (v) => JSON.stringify(toJson(v));
+    toJsonSerializers.set(serialize, stringify);
+  }
+  return { serialize, deserialize };
+}
+const sizesEntries = [];
+const valuesEntries = [];
+function roundTrip(serialize, deserialize, value) {
+  serContext.reset();
+  const serialized = serialize(value);
+  const deserialized = deserialize(serialized);
+  if (DEBUG) {
+    const stringify = toJsonSerializers.get(serialize);
+    let json = "";
+    try {
+      json = new Blob([stringify(value)]).size;
+    } catch (e) {
+      json = "-";
+    }
+    const sizes = { name: expect.getState().currentTestName, json, binary: serialized.byteLength };
+    sizesEntries.push(sizes);
+    valuesEntries.push({ value, deserialized });
+  }
+  const result = { serialized, deserialized };
+  return result;
+}
+afterAll(() => {
+  if (sizesEntries.length) console.table(sizesEntries);
+  if (valuesEntries.length) console.table(valuesEntries);
+});
+export {
+  createSerializationCallSignatureParamsFn,
+  createSerializationCallSignatureReturnFn,
+  createSerializationFns,
+  createSerializationParamsFn,
+  createSerializationReturnFn,
+  desContext,
+  roundTrip,
+  serContext
+};
+//# sourceMappingURL=binaryHelpers.js.map

package/.dist/esm/src/jitCompilers/binary/binarySpec/binaryHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binaryHelpers.js","sources":["../../../../../../src/jitCompilers/binary/binarySpec/binaryHelpers.ts"],"sourcesContent":["/* ########\n * 2025 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## */\n\nimport {JitFunctions} from '../../../constants.functions.ts';\nimport {FunctionRunType} from '../../../nodes/function/function.ts';\nimport type {DataViewDeserializer, DataViewSerializer, StrictArrayBuffer} from '@mionjs/core';\nimport type {InterfaceRunType} from '../../../nodes/collection/interface.ts';\nimport type {RunType} from '../../../types.ts';\nimport {createDataViewDeserializer, createDataViewSerializer, setSerializationOptions, getENV} from '@mionjs/core';\nimport {afterAll, expect} from 'vitest';\n\nconst DEBUG = getENV('DEBUG_JIT') === 'print';\n/** maps a binary serializer to json serializer */\nconst toJsonSerializers: Map<(v: any) => any, (v: any) => string> = new Map();\n\nsetSerializationOptions({bufferSize: 1024});\nexport const serContext: DataViewSerializer = createDataViewSerializer('test');\nexport const desContext: DataViewDeserializer = createDataViewDeserializer('test', new ArrayBuffer(0));\n\nconst SERIALIZE_FN = JitFunctions.toBinary;\nconst DESERIALIZE_FN = JitFunctions.fromBinary;\n\nexport function createSerializationFns(rt: RunType) {\n    const toBinary = rt.createJitFunction(SERIALIZE_FN);\n    const fromBinary = rt.createJitFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number) {\n    const params = typeof sliceStart === 'number' ? {paramsSlice: {start: sliceStart}} : undefined;\n    const toBinary = rt.createJitParamsFunction(SERIALIZE_FN, params);\n    const fromBinary = rt.createJitParamsFunction(DESERIALIZE_FN, params);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitParamsFunction(JitFunctions.prepareForJson, params);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationReturnFn(rt: FunctionRunType) {\n    const toBinary = rt.createJitReturnFunction(SERIALIZE_FN);\n    const fromBinary = rt.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = rt.createJitReturnFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const toBinary = callSignature.createJitParamsFunction(SERIALIZE_FN);\n    const fromBinary = callSignature.createJitParamsFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = callSignature.createJitParamsFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const toBinary = callSignature.createJitReturnFunction(SERIALIZE_FN);\n    const fromBinary = callSignature.createJitReturnFunction(DESERIALIZE_FN);\n    const serialize = (v: any) => (toBinary(v, serContext), serContext.getBuffer());\n    const deserialize = (data: StrictArrayBuffer) => (desContext.setBuffer(data), fromBinary(undefined, desContext));\n    if (DEBUG) {\n        const toJson = callSignature.createJitReturnFunction(JitFunctions.prepareForJson);\n        const stringify = (v: any) => JSON.stringify(toJson(v));\n        toJsonSerializers.set(serialize, stringify);\n    }\n    return {serialize, deserialize};\n}\n\nconst sizesEntries: any[] = [];\nconst valuesEntries: any[] = [];\n\nexport function roundTrip(serialize: (v: any) => StrictArrayBuffer, deserialize: (v: StrictArrayBuffer) => any, value: any) {\n    serContext.reset();\n    const serialized = serialize(value);\n    const deserialized = deserialize(serialized);\n    if (DEBUG) {\n        const stringify = toJsonSerializers.get(serialize)!;\n        let json: number | string = '';\n        // eslint-disable-next-line\n        try { json = new Blob([stringify(value)]).size; } catch (e) { json = '-'; } // prettier-ignore\n        const sizes = {name: expect.getState().currentTestName, json, binary: serialized.byteLength};\n        sizesEntries.push(sizes);\n        valuesEntries.push({value, deserialized});\n    }\n    const result = {serialized, deserialized};\n    return result;\n}\n\nafterAll(() => {\n    if (sizesEntries.length) console.table(sizesEntries);\n    if (valuesEntries.length) console.table(valuesEntries);\n});\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/jitCompilers/binary/fromBinary.d.ts

@@ -0,0 +1,7 @@
+import { jitBinaryDeserializerArgs, JitFunctions } from '../../constants.functions.ts';
+import { JitCode } from '../../types.ts';
+import { BaseRunType } from '../../lib/baseRunTypes.ts';
+import { BaseFnCompiler } from '../../lib/jitFnCompiler.ts';
+type BinaryCompiler = BaseFnCompiler<typeof jitBinaryDeserializerArgs, typeof JitFunctions.fromBinary.id>;
+export declare function emitFromBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode;
+export {};