npm - @mionjs/run-types - Versions diffs - 0.8.3-alpha.0 → 0.8.4 - Mend

@mionjs/run-types 0.8.3-alpha.0 → 0.8.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (119) hide show

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

	@@ -1 +1 @@
1	- {"version":3,"file":"createRunType.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
1	+ {"version":3,"file":"createRunType.js","sources":["../../../src/createRunType.ts"],"sourcesContent":["/* eslint-disable no-case-declarations /\n/ ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## /\n\nimport type {RunType, Mutable, SrcType} from './types.ts';\nimport type {BaseRunType} from './lib/baseRunTypes.ts';\nimport type {TypeClass, Type} from '@deepkit/type';\nimport {ReflectionKind, resolveReceiveType, ReceiveType, reflect, typeAnnotation, stringifyType} from '@deepkit/type';\nimport {\n hasArguments,\n hasExtendsArguments,\n hasImplements,\n hasIndexType,\n hasParameters,\n hasReturn,\n hasType,\n hasTypes,\n isNativeUtilityStringTypes,\n isNonSerializableClass,\n isNonSerializableObject,\n} from './lib/guards.ts';\nimport {StringRunType} from './nodes/atomic/string.ts';\nimport {DateRunType} from './nodes/atomic/date.ts';\nimport {NumberRunType} from './nodes/atomic/number.ts';\nimport {BooleanRunType} from './nodes/atomic/boolean.ts';\nimport {NullRunType} from './nodes/atomic/null.ts';\nimport {BigIntRunType} from './nodes/atomic/bigInt.ts';\nimport {AnyRunType} from './nodes/atomic/any.ts';\nimport {UndefinedRunType} from './nodes/atomic/undefined.ts';\nimport {UnknownRunType} from './nodes/atomic/unknown.ts';\nimport {VoidRunType} from './nodes/atomic/void.ts';\nimport {ArrayRunType} from './nodes/member/array.ts';\nimport {LiteralRunType} from './nodes/atomic/literal.ts';\nimport {RegexpRunType} from './nodes/atomic/regexp.ts';\nimport {NeverRunType} from './nodes/atomic/never.ts';\nimport {EnumRunType} from './nodes/atomic/enum.ts';\nimport {EnumMemberRunType} from './nodes/atomic/enumMember.ts';\nimport {UnionRunType} from './nodes/collection/union.ts';\nimport {TupleRunType} from './nodes/collection/tuple.ts';\nimport {FunctionParamsRunType} from './nodes/collection/functionParams.ts';\nimport {TupleMemberRunType} from './nodes/member/tupleMember.ts';\nimport {InterfaceRunType} from './nodes/collection/interface.ts';\nimport {PropertyRunType} from './nodes/member/property.ts';\nimport {IndexSignatureRunType} from './nodes/member/indexProperty.ts';\nimport {MethodSignatureRunType} from './nodes/member/methodSignature.ts';\nimport {CallSignatureRunType} from './nodes/member/callSignature.ts';\nimport {FunctionRunType} from './nodes/function/function.ts';\nimport {PromiseRunType} from './nodes/native/promise.ts';\nimport {ObjectRunType} from './nodes/atomic/object.ts';\nimport {IntersectionRunType} from './nodes/collection/intersection.ts';\nimport {ParameterRunType} from './nodes/member/param.ts';\nimport {MethodRunType} from './nodes/member/method.ts';\nimport {RestParamsRunType} from './nodes/member/restParams.ts';\nimport {ClassRunType} from './nodes/collection/class.ts';\nimport {MapRunType} from './nodes/native/map.ts';\nimport {ReflectionSubKind} from './constants.kind.ts';\nimport {SetRunType} from './nodes/native/set.ts';\nimport {SymbolRunType} from './nodes/atomic/symbol.ts';\nimport {NonSerializableRunType} from './nodes/native/nonSerializable.ts';\nimport {registerErrorDeserializers} from '@mionjs/core';\n\nexport function runType<T>(type?: ReceiveType<T>): RunType {\n const start = Date.now();\n const src = resolveReceiveType(type) as SrcType;\n const took0 = Date.now() - start;\n createRunTypes(src);\n const took1 = Date.now() - start;\n const diff = took1 - took0;\n // max RunType overhead 60 ms\n if (diff > 60) console.warn(`RunType overhead is very long: ${diff}ms for ${stringifyType(src)}`);\n return src._rt;\n}\n\nexport function reflectFunction<Fn extends (...args: any[]) => any>(fn: Fn): FunctionRunType {\n const src = reflect(fn) as SrcType;\n runType(src);\n return src._rt as FunctionRunType;\n}\n\n// We need to traverse all possible associated nodes to create all the runTypes\nfunction createRunTypes(src: SrcType): void {\n registerErrorDeserializers();\n const stack: Type[] = [src];\n\n while (stack.length > 0) {\n const current = stack.pop();\n if (!current \|\| (current as SrcType)._rt) continue;\n\n try {\n createRunType(current as Mutable<SrcType>);\n } catch (error) {\n const typesStackMessage = '\\nTypes Stack: ' + stack.map((t) => t.typeName \|\| t.kind).join(', ');\n (error as Error).message += typesStackMessage;\n throw error;\n }\n\n // single child type nodes\n if (hasType(current)) stack.push(current.type);\n if (hasReturn(current)) stack.push(current.return);\n if (hasIndexType(current)) stack.push(current.indexType);\n if (current.origin) stack.push(current.origin);\n if (current.indexAccessOrigin?.index) stack.push(current.indexAccessOrigin?.index);\n if (current.indexAccessOrigin?.container) stack.push(current.indexAccessOrigin?.container);\n\n // multiple child type nodes\n if (hasTypes(current)) pushToStack(current.types, stack);\n if (hasParameters(current)) pushToStack(current.parameters, stack);\n if (hasArguments(current)) pushToStack(current.arguments, stack);\n if (hasExtendsArguments(current)) pushToStack(current.extendsArguments, stack);\n if (hasImplements(current)) pushToStack(current.implements, stack);\n if (current.typeArguments) pushToStack(current.typeArguments, stack);\n if (current.decorators) pushToStack(current.decorators, stack);\n if (current.scheduleDecorators) pushToStack(current.scheduleDecorators, stack);\n\n // annotations\n if (current.annotations) {\n const annotations = typeAnnotation.getAnnotations(current);\n for (const annotation of annotations) stack.push(annotation.options);\n }\n\n // originTypes\n current.originTypes?.forEach((ot) => {\n if (ot.typeArguments) pushToStack(ot.typeArguments, stack);\n });\n\n // sometimes parent is an orphan so we need to explicitly add it to the stack\n if (current.parent && !(current.parent as SrcType)?._rt) stack.push(current.parent);\n }\n}\n\nfunction pushToStack(subTypes: Type[], stack: Type[]) {\n if (Array.isArray(subTypes)) stack.push(...subTypes);\n}\n\nfunction createRunType(deepkitType: Mutable<SrcType>): RunType {\n // console.log('deepkitType', deepkitType);\n\n /\n RunType reference is stored in the deepkitType._runType so we can access both the deepkitType and the mion RunType,\n basically every runType stores a reference to a deepkit type and vice versa.\n This also relies on deepkit handling circular types to prevent infinite loop when we are generating RunTypes.\n */\n const existingType: RunType \| undefined = deepkitType._rt;\n // TODO: IMPORTANT: seems like deepkit can generate multiple types objects for the same type, so we need to handle this\n // we are attaching the runType to the deepkit type (deepkitType._runType), to link the two types together\n // but as deepkit can generate multiple types that means existingType will be null and the markAsCircular function is not working as expected\n if (existingType) return existingType;\n\n let rt: BaseRunType;\n\n switch (deepkitType.kind) {\n // ###################### ATOMIC RUNTYPES ######################\n // Primitive types and other atomic types that don't contain other types\n case ReflectionKind.any:\n rt = new AnyRunType();\n break;\n case ReflectionKind.bigint:\n rt = new BigIntRunType();\n break;\n case ReflectionKind.boolean:\n rt = new BooleanRunType();\n break;\n case ReflectionKind.enum:\n rt = new EnumRunType();\n break;\n case ReflectionKind.enumMember:\n // enum members are resolved by the enum type, so this is not expected to be called\n rt = new EnumMemberRunType();\n break;\n case ReflectionKind.literal:\n rt = new LiteralRunType();\n break;\n case ReflectionKind.never:\n // TODO add the string format feature\n rt = isNativeUtilityStringTypes(deepkitType) ? new StringRunType() : new NeverRunType();\n break;\n case ReflectionKind.null:\n rt = new NullRunType();\n break;\n case ReflectionKind.number:\n rt = new NumberRunType();\n break;\n case ReflectionKind.object:\n rt = new ObjectRunType();\n break;\n case ReflectionKind.regexp:\n rt = new RegexpRunType();\n break;\n case ReflectionKind.string:\n rt = new StringRunType();\n break;\n case ReflectionKind.symbol:\n rt = new SymbolRunType();\n break;\n case ReflectionKind.templateLiteral:\n // deepkit automatically resolves template literals unions to literals\n // this is only called when you define the type of a template literal i.e: type T = `foo${string}`;\n // this is not supported at the moment but would be useful for type safe urls etc\n throw new Error(\n '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`'\n );\n case ReflectionKind.undefined:\n rt = new UndefinedRunType();\n break;\n case ReflectionKind.unknown:\n rt = new UnknownRunType();\n break;\n case ReflectionKind.void:\n rt = new VoidRunType();\n break;\n\n // ###################### MEMBER RUNTYPES ######################\n // Types that represent members of collections or other structures\n case ReflectionKind.array:\n rt = new ArrayRunType();\n break;\n case ReflectionKind.callSignature:\n rt = new CallSignatureRunType();\n break;\n case ReflectionKind.function:\n if (deepkitType.subKind === ReflectionSubKind.params) {\n rt = new FunctionParamsRunType();\n } else {\n const frt = new FunctionRunType();\n // TODO review an change how we compile function parameters and return type\n // those should also be jit functions, no need to check for array\n // and maybe add option to target individual parameters\n (frt.parameterRunTypes as Mutable<RunType>).src = deepkitType;\n rt = frt;\n }\n break;\n case ReflectionKind.indexSignature:\n rt = new IndexSignatureRunType();\n break;\n case ReflectionKind.method:\n rt = new MethodRunType();\n break;\n case ReflectionKind.methodSignature:\n rt = new MethodSignatureRunType();\n break;\n case ReflectionKind.parameter:\n rt = new ParameterRunType();\n break;\n case ReflectionKind.property:\n case ReflectionKind.propertySignature:\n rt = new PropertyRunType();\n break;\n case ReflectionKind.rest:\n rt = new RestParamsRunType();\n break;\n case ReflectionKind.tupleMember:\n rt = new TupleMemberRunType();\n break;\n case ReflectionKind.promise:\n rt = new PromiseRunType();\n break;\n\n // ###################### COLLECTION RUNTYPES ######################\n case ReflectionKind.objectLiteral:\n if (isNonSerializableObject(deepkitType)) {\n rt = new NonSerializableRunType();\n } else {\n rt = new InterfaceRunType();\n }\n break;\n case ReflectionKind.class:\n rt = initClassRunType(deepkitType);\n break;\n // Types that contain other types as members\n case ReflectionKind.infer:\n throw new Error(\n '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'\n );\n\n case ReflectionKind.intersection:\n rt = new IntersectionRunType();\n break;\n\n case ReflectionKind.tuple:\n rt = new TupleRunType();\n break;\n case ReflectionKind.typeParameter:\n throw new Error(\n 'TypeParameter not implemented. Type parameters are the generic placeholders in type definitions (e.g., T in Array<T>, ErrType in TypedError<ErrType>). ' +\n 'Type parameters are typically resolved during type instantiation and should not appear in runtime type checking.' +\n 'This error is typically caused by a generic type missing type arguments, e.g.: TypedError instead of TypedError<\"my-error\">.'\n );\n // rType = resolveTypeParameter(deepkitType, opts, mapper);\n case ReflectionKind.union:\n rt = new UnionRunType();\n break;\n default:\n rt = new AnyRunType();\n break;\n }\n rt.onCreated(deepkitType);\n // console.log('rt', rt);\n return rt;\n}\n\nfunction initClassRunType(src: TypeClass & {subKind?: number}): BaseRunType {\n switch (src.classType) {\n case Date:\n src.subKind = ReflectionSubKind.date;\n return new DateRunType();\n case Map:\n src.subKind = ReflectionSubKind.map;\n return new MapRunType();\n case Set:\n src.subKind = ReflectionSubKind.set;\n return new SetRunType();\n default:\n if (isNonSerializableClass(src)) {\n src.subKind = ReflectionSubKind.nonSerializable;\n return new NonSerializableRunType();\n }\n return new ClassRunType();\n }\n}\n"],"names":[],"mappings":"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"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"createRunTypeFunctions.js","sources":[],"sourcesContent":[],"names":[],"mappings":"~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~"}
1	+ {"version":3,"file":"createRunTypeFunctions.js","sources":["../../../src/createRunTypeFunctions.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 {ReceiveType} from '@deepkit/type';\nimport {runType} from './createRunType.ts';\nimport {RunTypeOptions} from './types.ts';\nimport {\n FromBinaryFn,\n IsTypeFn,\n JsonStringifyFn,\n PrepareForJsonFn,\n RestoreFromJsonFn,\n ToBinaryFn,\n ToCodeFn,\n TypeErrorsFn,\n} from '@mionjs/core';\nimport {BaseRunType} from './lib/baseRunTypes.ts';\nimport {registerJitFunctionCompiler} from './lib/jitFnsRegistry.ts';\n\n// All these functions are async because they might need to compile the jit function first\n// At the moment they are compiled synchronously, but in the future they might be async\n// Also some the src code to compile or functionality of the JIT functions might be loaded dynamically\n// ie: mocking functionality is loaded only when mockTypeFn is called\n\n/* Returns a function that checks if the given value is of the specified type. /\nexport async function createIsTypeFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<IsTypeFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.isType, opts);\n}\n\n/* Returns a function that get Type error data. /\nexport async function createTypeErrorsFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<TypeErrorsFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.typeErrors, opts);\n}\n\n/\n Returns a function that prepares a javascript type to be compatible with json.stringify.\n * Allows json.stringify special types like dates, bigints, maps, set, etc... that are not supported by json.stringify\n /\nexport async function createPrepareForJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<PrepareForJsonFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.prepareForJson, opts);\n}\n\n/\n Returns a function that restores a javascript type from json.parse.\n * Allows restoring special types like dates, bigints, maps, set, etc... that are not supported by json.parse\n * /\nexport async function createRestoreFromJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<RestoreFromJsonFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.restoreFromJson, opts);\n}\n\n/\n Returns a function that stringifies a javascript value to a json string.\n * Stringifies special types like dates, bigints, maps, set, etc...\n * Is equivalent to calling prepareForJson and then json.stringify but more efficient.\n /\nexport async function createStringifyJsonFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<JsonStringifyFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.stringifyJson, opts);\n}\n\n/* Returns a function that serializes any type value to a binary format. /\nexport async function createToBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<ToBinaryFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.toBinary, opts);\n}\n\n/* Returns a function that deserializes a binary value to the specified type. /\nexport async function createFromBinaryFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): Promise<FromBinaryFn> {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.fromBinary, opts);\n}\n\n/* Returns a function that converts a value to javascript code, including set etc /\nexport function createToJavascriptFn<T>(opts?: RunTypeOptions, type?: ReceiveType<T>): ToCodeFn {\n const rt = runType(type);\n return rt.createJitFunction(JitFunctions.toJSCode, opts);\n}\n\n/* Returns a function that mocks a value of the specified type. */\nexport async function createMockTypeFn<T>(type?: ReceiveType<T>): Promise<(opts?: Partial<RunTypeOptions>) => T> {\n const rt = runType(type) as BaseRunType;\n await registerJitFunctionCompiler(JitFunctions.mock);\n return (opts?: Partial<RunTypeOptions>) => rt.mockType(opts) as T;\n}\n"],"names":["__ΩRunTypeOptions"],"mappings":";;;;;;;;;;;AA8BA,eAAsB,eAAkB,MAAuB,OAAzC,eAAc,IAAA,CAAA,GAAgD;AAA9D,iBAAc,IAAA;AAChC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,QAAQ,IAAI;AACxD;;AAGD,eAAsB,mBAAsB,MAAuB,OAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,YAAY,IAAI;AAC5D;;AAMD,eAAsB,uBAA0B,MAAuB,OAAjD,uBAAsB,IAAA,CAAA,GAAgD;AAAtE,yBAAsB,IAAA;AACxC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,gBAAgB,IAAI;AAChE;;AAMD,eAAsB,wBAA2B,MAAuB,OAAlD,wBAAuB,IAAA,CAAA,GAAgD;AAAvE,0BAAuB,IAAA;AACzC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,iBAAiB,IAAI;AACjE;;AAOD,eAAsB,sBAAyB,MAAuB,OAAhD,sBAAqB,IAAA,CAAA,GAAgD;AAArE,wBAAqB,IAAA;AACvC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,eAAe,IAAI;AAC/D;;AAGD,eAAsB,iBAAoB,MAAuB,OAA3C,iBAAgB,IAAA,CAAA,GAAgD;AAAhE,mBAAgB,IAAA;AAClC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,mBAAsB,MAAuB,OAA7C,mBAAkB,IAAA,CAAA,GAAgD;AAAlE,qBAAkB,IAAA;AACpC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,YAAY,IAAI;AAC5D;;SAGe,qBAAwB,MAAuB,OAA/C,qBAAoB,IAAA,CAAA,GAAgD;AAApE,uBAAoB,IAAA;AAChC,QAAM,KAAK,QAAQ,IAAI;AACvB,SAAO,GAAG,kBAAkB,aAAa,UAAU,IAAI;AAC1D;;AAGD,eAAsB,iBAAoB,OAApB,iBAAgB,IAAA,CAAA,GAAyB;AAAzC,mBAAgB,IAAA;AAClC,QAAM,KAAK,QAAQ,IAAI;AACvB,QAAM,4BAA4B,aAAa,IAAI;AACnD,SAAA,aAAO,CAAC,SAAmC,GAAG,SAAS,IAAI,GAAM,CAAA,MAAA,YAAA,MAAAA,mBAAA,QAAA,IAAA,cAAA,CAAA;AACpE;;"}

package/.dist/esm/src/jitCompilers/json/toJsCode.js CHANGED Viewed

@@ -4,14 +4,6 @@ import { JitFunctions } from "../../constants.functions.js";
 import { isSafePropName } from "../../lib/utils.js";
 import { createStringifyCompiler, createStringifyIterable } from "./stringifyJson.js";
 import { cpf_sanitizeCompiledFn } from "../../run-types-pure-fns.js";
-function getParentSiblingNames(srcMS) {
-  let parent = srcMS.parent;
-  if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;
-  if (parent?.kind !== ReflectionKind.objectLiteral) return void 0;
-  const types = parent.types;
-  if (!types) return void 0;
-  return new Set(types.map((t) => t.name).filter((n) => n !== void 0));
-}
 function createToCodeCompiler() {
   const fnID = JitFunctions.toJSCode.id;
   const visitJsonStringify = createStringifyCompiler(fnID);
@@ -37,11 +29,14 @@ function createToCodeCompiler() {
         if (isCompilingFnProp(rt, comp)) {
           return { code: `'undefined'`, type: "E" };
         } else if (isCompilingClosureFn(rt, comp)) {
+          const parentRef = getParentObjRef(srcMS, comp);
           const isPureFn = rt.getChildVarName(comp) === "createPureFn";
-          const fnName = isPureFn ? `${comp.vλl}.fnName` : `${comp.vλl}.jitFnHash`;
-          const fnCode = `${comp.vλl}.code`;
-          const paramList = isPureFn ? `${comp.vλl}.paramNames.join(',')` : `'utl'`;
+          const fnName = isPureFn ? `${parentRef}.fnName` : `${parentRef}.jitFnHash`;
+          const fnCode = `${parentRef}.code`;
+          const paramList = isPureFn ? `${parentRef}.paramNames.join(',')` : `'utl'`;
           const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;
+          const isWrapped = parentRef !== comp.vλl;
+          if (isWrapped) return { code: closureCode, type: "E" };
           return { code: `'${safeName}:'+${closureCode}${sep}`, type: "E" };
         } else if (rt.src.subKind === ReflectionSubKind.params) {
           const paramsCode = visitJsonStringify(rt, comp);
@@ -94,21 +89,6 @@ function createToCodeCompiler() {
         return visitJsonStringify(runType, comp);
     }
   }
-  function isCompilingClosureFn(runType, comp) {
-    const childName = runType.getChildVarName(comp);
-    if (childName !== "createJitFn" && childName !== "createPureFn") return false;
-    const siblings = getParentSiblingNames(runType.src);
-    if (!siblings) return false;
-    if (!siblings.has("code")) return false;
-    if (childName === "createJitFn") return siblings.has("jitFnHash");
-    return siblings.has("bodyHash");
-  }
-  function isCompilingFnProp(runType, comp) {
-    if (runType.getChildVarName(comp) !== "fn") return false;
-    const siblings = getParentSiblingNames(runType.src);
-    if (!siblings) return false;
-    return siblings.has("code") && (siblings.has("createJitFn") || siblings.has("createPureFn"));
-  }
   return compileToCode;
 }
 let lazyFn = void 0;
@@ -116,6 +96,34 @@ function emitToCode(runType, comp) {
   if (!lazyFn) lazyFn = createToCodeCompiler();
   return lazyFn(runType, comp);
 }
+function getParentSiblingNames(srcMS) {
+  let parent = srcMS.parent;
+  if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;
+  if (parent?.kind !== ReflectionKind.objectLiteral) return void 0;
+  const types = parent.types;
+  if (!types) return void 0;
+  return new Set(types.map((t) => t.name).filter((n) => n !== void 0));
+}
+function isCompilingClosureFn(runType, comp) {
+  const childName = runType.getChildVarName(comp);
+  if (childName !== "createJitFn" && childName !== "createPureFn") return false;
+  const siblings = getParentSiblingNames(runType.src);
+  if (!siblings) return false;
+  if (childName === "createJitFn") return siblings.has("jitFnHash");
+  return siblings.has("bodyHash");
+}
+function isCompilingFnProp(runType, comp) {
+  if (runType.getChildVarName(comp) !== "fn") return false;
+  const siblings = getParentSiblingNames(runType.src);
+  if (!siblings) return false;
+  return siblings.has("createJitFn") && siblings.has("jitFnHash") || siblings.has("createPureFn") && siblings.has("bodyHash");
+}
+function getParentObjRef(_srcMS, comp) {
+  const stack = comp.stack;
+  const parentItem = stack[stack.length - 2];
+  if (parentItem && parentItem.vλl !== comp.vλl) return parentItem.vλl;
+  return comp.vλl;
+}
 export {
   createToCodeCompiler,
   emitToCode

package/.dist/esm/src/jitCompilers/json/toJsCode.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"toJsCode.js","sources":["../../../../../src/jitCompilers/json/toJsCode.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 type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {ClassRunType} from '../../nodes/collection/class.ts';\nimport type {MethodSignatureRunType} from '../../nodes/member/methodSignature.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport {ReflectionKind, type TypeMethodSignature, type TypeObjectLiteral, type TypePropertySignature} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {isSafePropName} from '../../lib/utils.ts';\nimport {createStringifyCompiler, createStringifyIterable} from './stringifyJson.ts';\nimport {cpf_sanitizeCompiledFn} from '../../run-types-pure-fns.ts';\n\n/* Gets sibling property/method names from a MethodSignature's parent ObjectLiteral /\nfunction getParentSiblingNames(srcMS: TypeMethodSignature): Set<string \| number \| symbol> \| undefined {\n let parent = srcMS.parent as any;\n // Handle deepkit bug where parent can be TypePropertySignature instead of TypeObjectLiteral\n if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;\n if (parent?.kind !== ReflectionKind.objectLiteral) return undefined;\n const types = (parent as TypeObjectLiteral).types;\n if (!types) return undefined;\n return new Set(types.map((t: any) => t.name).filter((n: any) => n !== undefined));\n}\n\nexport function createToCodeCompiler() {\n const fnID = JitFunctions.toJSCode.id;\n const visitJsonStringify = createStringifyCompiler(fnID);\n const visitJsonStringifyIterable = createStringifyIterable(fnID);\n\n /\n Compiles jit code to generate JavaScript code from data structures that match a Type.\n * Process is similar to transform JS to JSON, but with few differences.\n \n 1 - jitFunctions and pureFunctions are emitted as src code\n * 2 - Some native classes are supported and initialized using the new operator, ie: new Map(<data>), new Set(<data>), new Date(<data>), etc...\n \n THIS IS MOSTLY USED INTERNALLY FOR AOT CODE GENERATION AND A VERY BASIC IMPLEMENTATION.\n * !!! NOT INTENDED FOR PUBLIC USE !!!\n /\n function compileToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n const src = runType.src;\n const kind = src.kind;\n\n switch (kind) {\n // ###################### ATOMIC RUNTYPES ######################\n case ReflectionKind.undefined:\n return {code: `'undefined'`, type: 'E'};\n case ReflectionKind.symbol:\n return {code: `'Symbol('+'\"'+${comp.vλl}.description+'\"'+')'`, type: 'E'};\n // ###################### MEMBER RUNTYPES ######################\n case ReflectionKind.methodSignature: {\n const rt = runType as MethodSignatureRunType;\n const srcMS = src as TypeMethodSignature;\n const accessor = srcMS.name;\n const name = String(accessor);\n const isSafe = isSafePropName(accessor);\n const safeName = isSafe ? name : JSON.stringify(name);\n const sep = rt.skipCommas ? '' : '+\",\"';\n if (isCompilingFnProp(rt, comp)) {\n // special case for JitFunctions/PureFunctions that we know should return undefined for fn param\n return {code: `'undefined'`, type: 'E'};\n } else if (isCompilingClosureFn(rt, comp)) {\n // special case for JitFunctions/PureFunctions where we generate the fn from the data instead of fn.toString()\n const isPureFn = rt.getChildVarName(comp) === 'createPureFn';\n const fnName = isPureFn ? `${comp.vλl}.fnName` : `${comp.vλl}.jitFnHash`;\n const fnCode = `${comp.vλl}.code`;\n const paramList = isPureFn ? `${comp.vλl}.paramNames.join(',')` : `'utl'`;\n const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;\n return {code: `'${safeName}:'+${closureCode}${sep}`, type: 'E'};\n } else if (rt.src.subKind === ReflectionSubKind.params) {\n const paramsCode = visitJsonStringify(rt, comp);\n if (rt.isOptional())\n return {\n code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${paramsCode?.code}${sep})`,\n type: 'E',\n };\n return {code: `'${safeName}:'+${paramsCode?.code}${sep}`, type: 'E'};\n } else {\n const fnName = comp.addPureFunction(cpf_sanitizeCompiledFn);\n const parent = srcMS.parent as any as TypePropertySignature;\n\n // in some scenarios the parent is a propertySignature instead the Expected TypeObjectLiteral so we have to handle that\n // this seems to be a deepkit bug when using omit and then redefining the property @see SrcCodeJitCompiledFn type\n const isDuplicatedChild = parent?.kind === ReflectionKind.propertySignature && parent?.name === srcMS.name;\n if (isDuplicatedChild) return {code: `${fnName}(${comp.vλl}.toString())`, type: 'E'};\n const accessorCode = isSafe ? `.${safeName}` : `[${safeName}]`;\n const fnCode = `${fnName}(${comp.vλl}${accessorCode}.toString())`;\n if (rt.isOptional())\n return {code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${fnCode}${sep})`, type: 'E'};\n return {code: `'${safeName}:'+${fnCode}${sep}`, type: 'E'};\n }\n }\n case ReflectionKind.function:\n case ReflectionKind.method:\n case ReflectionKind.callSignature:\n if (runType.src.subKind === ReflectionSubKind.params) {\n return visitJsonStringify(runType, comp);\n } else {\n // TODO: we are relying in fn.toString() to generate code, this might not work properly in all js engines\n return {code: `${comp.vλl}.toString()`, type: 'E'};\n }\n // ###################### COLLECTION RUNTYPES ######################\n case ReflectionKind.class: {\n switch (runType.src.subKind) {\n case ReflectionSubKind.date:\n return {code: `'new Date('+${visitJsonStringify(runType, comp).code}+')'`, type: 'E'};\n case ReflectionSubKind.map: {\n return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Map(', ')');\n }\n case ReflectionSubKind.set: {\n return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Set(', ')');\n }\n case ReflectionSubKind.nonSerializable:\n throw new Error(`Can not generate code for Non Serializable types.`);\n default: {\n const rt = runType as unknown as ClassRunType;\n throw new Error(`Can not generate code for classes. Class: ${rt.getClassName()}`);\n }\n }\n }\n default:\n return visitJsonStringify(runType, comp);\n }\n }\n\n /* Detects if we're compiling a createJitFn or createPureFn closure by checking sibling properties /\n function isCompilingClosureFn(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n const childName = runType.getChildVarName(comp);\n if (childName !== 'createJitFn' && childName !== 'createPureFn') return false;\n const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n if (!siblings) return false;\n if (!siblings.has('code')) return false;\n if (childName === 'createJitFn') return siblings.has('jitFnHash');\n return siblings.has('bodyHash'); // createPureFn\n }\n\n /* Detects if we're compiling the fn property of a JitCompiledFn or CompiledPureFunction */\n function isCompilingFnProp(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n if (runType.getChildVarName(comp) !== 'fn') return false;\n const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n if (!siblings) return false;\n return siblings.has('code') && (siblings.has('createJitFn') \|\| siblings.has('createPureFn'));\n }\n\n return compileToCode;\n}\n\n// lazy loading as this function wont be used often just for (AOT)\n// TODO move to async code loading (but this would need a big refactor of the router)\nlet lazyFn: undefined \| ((runType: BaseRunType, comp: JitFnCompiler) => JitCode) = undefined;\nexport function emitToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n if (!lazyFn) lazyFn = createToCodeCompiler();\n return lazyFn(runType, comp);\n}\n"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"toJsCode.js","sources":["../../../../../src/jitCompilers/json/toJsCode.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 type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {ClassRunType} from '../../nodes/collection/class.ts';\nimport type {MethodSignatureRunType} from '../../nodes/member/methodSignature.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport {ReflectionKind, type TypeMethodSignature, type TypeObjectLiteral, type TypePropertySignature} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {isSafePropName} from '../../lib/utils.ts';\nimport {createStringifyCompiler, createStringifyIterable} from './stringifyJson.ts';\nimport {cpf_sanitizeCompiledFn} from '../../run-types-pure-fns.ts';\n\nexport function createToCodeCompiler() {\n const fnID = JitFunctions.toJSCode.id;\n const visitJsonStringify = createStringifyCompiler(fnID);\n const visitJsonStringifyIterable = createStringifyIterable(fnID);\n\n /\n Compiles jit code to generate JavaScript code from data structures that match a Type.\n * Process is similar to transform JS to JSON, but with few differences.\n \n 1 - jitFunctions and pureFunctions are emitted as src code\n * 2 - Some native classes are supported and initialized using the new operator, ie: new Map(<data>), new Set(<data>), new Date(<data>), etc...\n \n THIS IS MOSTLY USED INTERNALLY FOR AOT CODE GENERATION AND A VERY BASIC IMPLEMENTATION.\n * !!! NOT INTENDED FOR PUBLIC USE !!!\n /\n function compileToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n const src = runType.src;\n const kind = src.kind;\n\n switch (kind) {\n // ###################### ATOMIC RUNTYPES ######################\n case ReflectionKind.undefined:\n return {code: `'undefined'`, type: 'E'};\n case ReflectionKind.symbol:\n return {code: `'Symbol('+'\"'+${comp.vλl}.description+'\"'+')'`, type: 'E'};\n // ###################### MEMBER RUNTYPES ######################\n case ReflectionKind.methodSignature: {\n const rt = runType as MethodSignatureRunType;\n const srcMS = src as TypeMethodSignature;\n const accessor = srcMS.name;\n const name = String(accessor);\n const isSafe = isSafePropName(accessor);\n const safeName = isSafe ? name : JSON.stringify(name);\n const sep = rt.skipCommas ? '' : '+\",\"';\n if (isCompilingFnProp(rt, comp)) {\n // special case for JitFunctions/PureFunctions that we know should return undefined for fn param\n return {code: `'undefined'`, type: 'E'};\n } else if (isCompilingClosureFn(rt, comp)) {\n // special case for JitFunctions/PureFunctions where we generate the fn from the data instead of fn.toString()\n // When using Pick/Omit, deepkit wraps methodSignature in a propertySignature,\n // so comp.vλl points to the fn value instead of the parent object. Use getParentObjRef to get the right ref.\n const parentRef = getParentObjRef(srcMS, comp);\n const isPureFn = rt.getChildVarName(comp) === 'createPureFn';\n const fnName = isPureFn ? `${parentRef}.fnName` : `${parentRef}.jitFnHash`;\n const fnCode = `${parentRef}.code`;\n const paramList = isPureFn ? `${parentRef}.paramNames.join(',')` : `'utl'`;\n const closureCode = `'function get_'+${fnName}+'('+${paramList}+'){'+${fnCode}+'}'`;\n // When wrapped in a propertySignature (Pick/Omit types), the outer handler already emits the property name\n const isWrapped = parentRef !== comp.vλl;\n if (isWrapped) return {code: closureCode, type: 'E'};\n return {code: `'${safeName}:'+${closureCode}${sep}`, type: 'E'};\n } else if (rt.src.subKind === ReflectionSubKind.params) {\n const paramsCode = visitJsonStringify(rt, comp);\n if (rt.isOptional())\n return {\n code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${paramsCode?.code}${sep})`,\n type: 'E',\n };\n return {code: `'${safeName}:'+${paramsCode?.code}${sep}`, type: 'E'};\n } else {\n const fnName = comp.addPureFunction(cpf_sanitizeCompiledFn);\n const parent = srcMS.parent as any as TypePropertySignature;\n\n // in some scenarios the parent is a propertySignature instead the Expected TypeObjectLiteral so we have to handle that\n // this seems to be a deepkit bug when using omit and then redefining the property @see SrcCodeJitCompiledFn type\n const isDuplicatedChild = parent?.kind === ReflectionKind.propertySignature && parent?.name === srcMS.name;\n if (isDuplicatedChild) return {code: `${fnName}(${comp.vλl}.toString())`, type: 'E'};\n const accessorCode = isSafe ? `.${safeName}` : `[${safeName}]`;\n const fnCode = `${fnName}(${comp.vλl}${accessorCode}.toString())`;\n if (rt.isOptional())\n return {code: `(${comp.getChildVλl()} === undefined ? \"\" : '${safeName}:'+${fnCode}${sep})`, type: 'E'};\n return {code: `'${safeName}:'+${fnCode}${sep}`, type: 'E'};\n }\n }\n case ReflectionKind.function:\n case ReflectionKind.method:\n case ReflectionKind.callSignature:\n if (runType.src.subKind === ReflectionSubKind.params) {\n return visitJsonStringify(runType, comp);\n } else {\n // TODO: we are relying in fn.toString() to generate code, this might not work properly in all js engines\n return {code: `${comp.vλl}.toString()`, type: 'E'};\n }\n // ###################### COLLECTION RUNTYPES ######################\n case ReflectionKind.class: {\n switch (runType.src.subKind) {\n case ReflectionSubKind.date:\n return {code: `'new Date('+${visitJsonStringify(runType, comp).code}+')'`, type: 'E'};\n case ReflectionSubKind.map: {\n return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Map(', ')');\n }\n case ReflectionSubKind.set: {\n return visitJsonStringifyIterable(runType as unknown as IterableRunType, comp, 'new Set(', ')');\n }\n case ReflectionSubKind.nonSerializable:\n throw new Error(`Can not generate code for Non Serializable types.`);\n default: {\n const rt = runType as unknown as ClassRunType;\n throw new Error(`Can not generate code for classes. Class: ${rt.getClassName()}`);\n }\n }\n }\n default:\n return visitJsonStringify(runType, comp);\n }\n }\n\n return compileToCode;\n}\n\n// lazy loading as this function wont be used often just for (AOT)\n// TODO move to async code loading (but this would need a big refactor of the router)\nlet lazyFn: undefined \| ((runType: BaseRunType, comp: JitFnCompiler) => JitCode) = undefined;\nexport function emitToCode(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n if (!lazyFn) lazyFn = createToCodeCompiler();\n return lazyFn(runType, comp);\n}\n\n/* Gets sibling property/method names from a MethodSignature's parent ObjectLiteral /\nfunction getParentSiblingNames(srcMS: TypeMethodSignature): Set<string \| number \| symbol> \| undefined {\n let parent = srcMS.parent as any;\n // Handle deepkit bug where parent can be TypePropertySignature instead of TypeObjectLiteral\n if (parent?.kind === ReflectionKind.propertySignature) parent = parent.parent;\n if (parent?.kind !== ReflectionKind.objectLiteral) return undefined;\n const types = (parent as TypeObjectLiteral).types;\n if (!types) return undefined;\n return new Set(types.map((t: any) => t.name).filter((n: any) => n !== undefined));\n}\n\n/* Detects if we're compiling a createJitFn or createPureFn closure by checking sibling properties /\nfunction isCompilingClosureFn(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n const childName = runType.getChildVarName(comp);\n if (childName !== 'createJitFn' && childName !== 'createPureFn') return false;\n const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n if (!siblings) return false;\n if (childName === 'createJitFn') return siblings.has('jitFnHash');\n return siblings.has('bodyHash'); // createPureFn\n}\n\n/* Detects if we're compiling the fn property of a JitCompiledFn or CompiledPureFunction /\nfunction isCompilingFnProp(runType: MethodSignatureRunType, comp: JitFnCompiler): boolean {\n if (runType.getChildVarName(comp) !== 'fn') return false;\n const siblings = getParentSiblingNames(runType.src as TypeMethodSignature);\n if (!siblings) return false;\n return (\n (siblings.has('createJitFn') && siblings.has('jitFnHash')) \|\| (siblings.has('createPureFn') && siblings.has('bodyHash'))\n );\n}\n\n/\n Gets the runtime reference to the parent object that contains the methodSignature.\n * When using Pick/Omit, deepkit wraps methodSignature in a propertySignature,\n * causing comp.vλl to point to the fn value (e.g. `obj.createJitFn`) instead of the parent object (`obj`).\n * Detects this by comparing the current vλl with the previous stack item's vλl.\n * If they differ, we are inside a propertySignature wrapper and use the parent stack item's vλl.\n */\nfunction getParentObjRef(_srcMS: TypeMethodSignature, comp: JitFnCompiler): string {\n const stack = comp.stack;\n const parentItem = stack[stack.length - 2];\n if (parentItem && parentItem.vλl !== comp.vλl) return parentItem.vλl;\n return comp.vλl;\n}\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/lib/baseRunTypes.d.ts CHANGED Viewed

@@ -52,7 +52,6 @@ export declare abstract class CollectionRunType<T extends Type> extends BaseRunT
     emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode;
     emitStripUnknownKeys(comp: JitFnCompiler): JitCode;
     emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
-    private getChildrenTypeID;
 }
 export declare abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {
     abstract isOptional(): boolean;
@@ -71,5 +70,4 @@ export declare abstract class MemberRunType<T extends Type> extends BaseRunType<
     emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode;
     visitToBinary(comp: JitFnCompiler): JitCode;
     visitFromBinary(comp: JitFnCompiler): JitCode;
-    private getMemberTypeID;
 }

package/.dist/esm/src/lib/baseRunTypes.js CHANGED Viewed

@@ -1,5 +1,4 @@
-import { getENV, createUniqueHash, getJitUtils, MAX_STACK_DEPTH } from "@mionjs/core";
-import { maxStackErrorMessage } from "../constants.js";
+import { getENV, createUniqueHash, getJitUtils } from "@mionjs/core";
 import { CodeTypes, JitFunctions } from "../constants.functions.js";
 import { ReflectionKind, stringifyType } from "@deepkit/type";
 import { getPropIndex, memorize } from "./utils.js";
@@ -204,22 +203,6 @@ class CollectionRunType extends BaseRunType {
     const codes = this.getJitChildren(comp).map((c) => comp.compileUnknownKeysToUndefined(c, S).code).filter((code) => !!code);
     return { code: codes.join(";"), type: S };
   }
-  getChildrenTypeID = memorize((stack = []) => {
-    if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);
-    const circularJitConf = this.checkIsCircularAndGetRefId(stack);
-    if (circularJitConf) return circularJitConf;
-    stack.push(this);
-    const childrenIds = [];
-    const children = this.getChildRunTypes();
-    for (const child of children) {
-      childrenIds.push(child.getTypeID());
-    }
-    const isArray = this.src.kind === ReflectionKind.tuple || this.src.kind === ReflectionKind.array;
-    const groupID = isArray ? `[${childrenIds.join(",")}]` : `{${childrenIds.join(",")}}`;
-    const kind = this.src.subKind || this.src.kind;
-    stack.pop();
-    return `${kind}${groupID}`;
-  });
 }
 class MemberRunType extends BaseRunType {
   /** used to compile json stringify */
@@ -284,20 +267,6 @@ class MemberRunType extends BaseRunType {
     if (!code?.code) return { code: void 0, type: S };
     return code;
   }
-  getMemberTypeID = memorize((stack = []) => {
-    if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);
-    const optional = this.isOptional() ? "?" : "";
-    const kind = this.src.name?.toString() || this.src.index?.kind || this.src.subKind || this.src.kind;
-    const kindID = `${kind}${optional}`;
-    const circularJitConf = this.checkIsCircularAndGetRefId(stack);
-    if (circularJitConf) return `${kindID}:${circularJitConf}`;
-    stack.push(this);
-    const member = this.getMemberType();
-    const memberTypeID = member.getTypeID();
-    const typeID = `${kindID}:${memberTypeID}`;
-    stack.pop();
-    return typeID;
-  });
 }
 export {
   AtomicRunType,

package/.dist/esm/src/lib/baseRunTypes.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"baseRunTypes.js","sources":["../../../../src/lib/baseRunTypes.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars /\n/ ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## /\nimport {MAX_STACK_DEPTH, JitCompiledFn, createUniqueHash, getJitUtils, getENV} from '@mionjs/core';\nimport type {\n RunType,\n Mutable,\n RunTypeChildAccessor,\n JitFnID,\n SrcType,\n SrcCollection,\n CustomVλl,\n JitFn,\n JitCode,\n RunTypeOptions,\n StrNumber,\n DeepPartial,\n RunTypeFamily,\n} from '../types.ts';\nimport type {mockType} from '../mocking/mockType.ts';\nimport {maxStackErrorMessage} from '../constants.ts';\nimport {type CodeType, JitFunctions, CodeTypes} from '../constants.functions.ts';\nimport {ReflectionKind, stringifyType} from '@deepkit/type';\nimport type {TypeIndexSignature, TypeProperty, Type} from '@deepkit/type';\nimport {getPropIndex, memorize} from './utils.ts';\nimport {createJitCompiler, MockJitCompiler} from './jitFnCompiler.ts';\nimport {getJITFnHash} from './createJitFunction.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport {type AnyKindName, getReflectionName} from '../constants.kind.ts';\nimport {initFormatAnnotations} from './formats.ts';\nimport {createTypeId} from './typeId.ts';\nimport {getJitFunctionCompiler, registerJitFunctionCompiler} from './jitFnsRegistry.ts';\nimport {defaultMockOptions} from '../mocking/constants.mock.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport abstract class BaseRunType<T extends Type = Type> implements RunType {\n isCircular?: boolean;\n readonly src: SrcType<T> = null as any; // real value will be set after construction by the createRunType function\n abstract getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function\n /\n This single functions controls whether or not the code for a type should be inlined into the parent function\n * or should create a separate jit function for it, add as a dependency and call it.\n * @returns\n /\n isJitInlined = (): boolean => {\n // if is circular, always create a separate jit function as need to self invoke\n if (this.isCircular) return false;\n if (getENV('DEBUG_JIT') === 'INLINED') return true;\n // all array are self invoked for isType and are usually repeated type like string[] or number[] so worth deduplicating\n if (this.src.kind === ReflectionKind.array) return false;\n // collection with name might be used in different places so worth deduplicating\n if (this.src.typeName && this.getFamily() === 'C') return false;\n return true;\n };\n getKindName = memorize((): AnyKindName => getReflectionName(this));\n getTypeName = (): string => this.src.typeName \|\| this.getKindName();\n stringify = memorize((): string => stringifyType(this.src));\n skipJit(comp: JitFnCompiler): boolean {\n return false;\n }\n /* Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. /\n getFormatTypeID(): string \| undefined {\n // _formatId is cached by computeDeepkitFormatID during getDeepkitTypeId call\n // Empty string means no format, undefined means not computed yet\n const formatId = (this.src as any)._formatId;\n return formatId \|\| undefined;\n }\n /* Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. /\n getTypeID(): StrNumber {\n if (this.src._typeId === undefined) {\n throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);\n }\n return this.src._typeId;\n }\n getJitHash(opts: RunTypeOptions): string {\n const optsCopy = {...opts};\n // remove mock options as not relevant for jit functionality\n if (optsCopy.mock) delete optsCopy.mock;\n return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));\n }\n getParent = (): BaseRunType \| undefined => (this.src.parent as SrcType)?._rt as BaseRunType;\n checkIsCircularAndGetRefId(stack: RunType[] = []): StrNumber \| undefined {\n const inStackIndex = stack.findIndex((rt) => {\n if (rt === this) return true;\n // some nodes seems to be different objects in memory but are the same id, so we check by id as well\n return rt.src.id && this.src.id && rt.src.id === this.src.id;\n }); // cant use isSameJitType because it uses getTypeID and would loop forever\n const inStackSrcId = stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);\n const isInStack = inStackIndex >= 0; // recursive reference\n if (isInStack) {\n this.isCircular = true;\n const name = this.src.typeName \|\| ''; // todo: not sure if all the circular references will have a name\n const refId = '$' + this.src.kind + `_${inStackIndex}` + name; // ensures different circular types have different typeID\n return refId;\n }\n return undefined;\n }\n /\n Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.\n * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.\n * /\n onCreated(src: SrcType<any>): void {\n (this as Mutable<RunType>).src = src;\n (src as Mutable<SrcType>)._rt = this;\n initFormatAnnotations(this);\n // Cache the type ID on the src object - this includes format information\n createTypeId(src);\n }\n /\n Some elements might need a standalone name variable that ignores the vλl value of the parents.\n * returns a variable that is being compiled, ignores the parents variable names /\n getCustomVλl(comp: JitFnCompiler): CustomVλl \| undefined {\n return undefined;\n }\n /\n Some elements might need a custom static path to be able to reference the source of an error.\n * ie: when validating a Map we need to differentiate if the value that failed is the key or the value of a map's entry.\n /\n getStaticPathLiteral(comp: JitFnCompiler): string \| number \| undefined {\n return undefined;\n }\n\n // ########## Mock ##########\n\n async mock(opts?: DeepPartial<RunTypeOptions>): Promise<any> {\n // although the mock function is not jit, it is also stored in the registry\n // this is because we don't want to load mock related functionality if not needed\n await registerJitFunctionCompiler(JitFunctions.mock);\n return this.mockType(opts);\n }\n\n /* synchronous version of mock, throws an error if the mock function has not been loaded /\n mockType(opts: DeepPartial<RunTypeOptions> = {}): any {\n const mockFn = getJitFunctionCompiler(JitFunctions.mock) as typeof mockType;\n if (!mockFn)\n throw new Error(\n `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`\n );\n const fnID = JitFunctions.mock.id;\n // options sent to the compiler will be set to empty as mock options are handled separately from the compiler\n const mockingOpts = {...opts, mock: {...defaultMockOptions, ...(opts.mock \|\| {})}} as RunTypeOptions;\n const hash = getJITFnHash(fnID, this, mockingOpts);\n const comp = new MockJitCompiler(this, mockingOpts, undefined, hash, this.getTypeID());\n return mockFn(this, comp);\n }\n\n // ########## Create Jit Functions ##########\n\n createJitFunction = (jitFn: JitFn, opts: RunTypeOptions = {}): ((...args: any[]) => any) => {\n return this.createJitCompiledFunction(jitFn.id, undefined, opts).fn;\n };\n\n createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts: RunTypeOptions = {}): JitCompiledFn {\n const fnHash = getJITFnHash(fnID, this, opts);\n const jitCompiled = getJitUtils().getJIT(fnHash);\n if (jitCompiled) {\n if (getENV('DEBUG_JIT') === 'VERBOSE')\n console.log(`\\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \\x1b[0m`);\n return jitCompiled;\n }\n const newJitCompiler: JitFnCompiler = createJitCompiler(\n this,\n fnID,\n parentCop,\n undefined,\n undefined,\n opts\n ) as JitFnCompiler;\n try {\n const codeType = this.getFamily() === 'A' ? E : S;\n newJitCompiler.compile(this, codeType, fnID);\n newJitCompiler.createJitFunction();\n } catch (e: any) {\n // if something goes wrong during compilation we want to remove the compiler from\n // the cache as this is automatically added to jitUtils cache during compilation\n newJitCompiler.removeFromJitCache();\n // TODO: we need to print the full path to the type that is causing the error\n // for this ideally we should add a parent Compiler and print the trace only from the root\n if (typeof e?.message === 'string' && !newJitCompiler.hasStackTrace(e.message))\n e.message += newJitCompiler.getStackTrace();\n throw e;\n }\n return newJitCompiler as JitCompiledFn;\n }\n\n // ########## emit Methods that generates src code ##########\n\n abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n // todo: maybe we should move these two into a single file like the rest of serializers\n abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n}\n\n/\n RunType that is atomic an does not contains any other child runTypes.\n * ie: string, number, boolean, any, null, undefined, void, never, bigint, etc.\n * /\nexport abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {\n getFamily(): 'A' {\n return 'A';\n }\n emitPrepareForJson(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: E};\n }\n emitUnknownKeyErrors(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n}\n\n/\n RunType that contains a collection or child runTypes.\n * Collection RunTypes are the only ones that can have circular references. as a child of a collection RunType can be the parent of the collection RunType.\n * i.e: interface, child runTypes are it's properties\n * i.e: tuple, it's child runTypes are the tuple members\n /\nexport abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {\n getFamily(): 'C' {\n return 'C';\n }\n getChildRunTypes = (): BaseRunType[] => {\n const childTypes = ((this.src as SrcCollection).types as SrcType[]) \|\| []; // deepkit stores child types in the types property\n return childTypes.map((t) => t._rt as BaseRunType);\n };\n getJitChildren(comp: JitFnCompiler): BaseRunType[] {\n let skipIndex = false; // if there are multiple index signatures, only the first one will be used as they must be same type just different keys\n return this.getChildRunTypes().filter((c) => {\n if (c.skipJit(comp)) return false;\n const isIndex = c.src.kind === ReflectionKind.indexSignature;\n if (isIndex && skipIndex) return false;\n if (isIndex) skipIndex = true;\n return true;\n });\n }\n areAllChildrenOptional(children: BaseRunType[]) {\n return children.every(\n (prop) =>\n (prop as MemberRunType<any>)?.isOptional() \|\|\n (prop.src as TypeProperty)?.optional \|\|\n prop.src.kind === ReflectionKind.indexSignature\n );\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileHasUnknownKeys(c, E).code)\n .filter((code) => !!code);\n return {code: codes.join(' \|\| '), type: E};\n }\n emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileUnknownKeyErrors(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileStripUnknownKeys(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileUnknownKeysToUndefined(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n private getChildrenTypeID = memorize((stack: BaseRunType<any>[] = []): StrNumber => {\n if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n const circularJitConf = this.checkIsCircularAndGetRefId(stack);\n if (circularJitConf) return circularJitConf;\n stack.push(this);\n const childrenIds: (string \| number)[] = [];\n const children = this.getChildRunTypes();\n for (const child of children) {\n childrenIds.push(child.getTypeID());\n }\n const isArray = this.src.kind === ReflectionKind.tuple \|\| this.src.kind === ReflectionKind.array;\n const groupID = isArray ? `[${childrenIds.join(',')}]` : `{${childrenIds.join(',')}}`;\n const kind = this.src.subKind \|\| this.src.kind;\n stack.pop();\n return `${kind}${groupID}`;\n });\n}\n\n/\n RunType that contains a single member or child RunType. usually part of a collection RunType.\n * i.e object properties, {prop: memberType} where memberType is the child RunType\n /\nexport abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {\n abstract isOptional(): boolean;\n abstract getChildVarName(comp: JitFnCompiler): string \| number;\n abstract getChildLiteral(comp: JitFnCompiler): string \| number;\n abstract useArrayAccessor(): boolean;\n /* used to compile json stringify /\n skipCommas?: boolean;\n /* used to compile json stringify */\n tempChildVλl?: string;\n getFamily(): 'M' {\n return 'M';\n }\n getMemberType(): BaseRunType {\n const memberType = (this.src as any).type as SrcType; // deepkit stores member types in the type property\n return memberType._rt as BaseRunType;\n }\n getChildIndex(comp: JitFnCompiler) {\n const start = comp?.opts?.paramsSlice?.start;\n if (start) return getPropIndex(this.src) - start;\n return getPropIndex(this.src);\n }\n getJitChild(comp: JitFnCompiler): BaseRunType \| undefined {\n const member: BaseRunType = this.getMemberType();\n if (member.skipJit(comp)) return undefined;\n return member;\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileHasUnknownKeys(child, E);\n if (!codeResult?.code) return {code: undefined, type: E};\n const childName = comp.getChildVλl();\n const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileUnknownKeyErrors(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileStripUnknownKeys(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileUnknownKeysToUndefined(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n visitToBinary(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const code = comp.compileToBinary(child, S);\n if (!code?.code) return {code: undefined, type: S};\n return this.isOptional()\n ? {code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S}\n : code;\n }\n visitFromBinary(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const code = comp.compileFromBinary(child, S);\n if (!code?.code) return {code: undefined, type: S};\n return code;\n }\n private getMemberTypeID = memorize((stack: BaseRunType<any>[] = []): StrNumber => {\n if (stack.length > MAX_STACK_DEPTH) throw new Error(maxStackErrorMessage);\n const optional = this.isOptional() ? '?' : '';\n const kind =\n (this.src as TypeProperty).name?.toString() \|\|\n (this.src as TypeIndexSignature).index?.kind \|\|\n this.src.subKind \|\|\n this.src.kind;\n const kindID = `${kind}${optional}`;\n const circularJitConf = this.checkIsCircularAndGetRefId(stack);\n if (circularJitConf) return `${kindID}:${circularJitConf}`;\n // TODO: some properties could be skipped from the JIT ID. so we could implement a mechanism to mark them to be skipped\n // ie: sample and sampleChars from StringFormat are too large but they do not affect jit code generation as those properties are only used during mocking\n stack.push(this);\n const member = this.getMemberType();\n const memberTypeID = member.getTypeID();\n const typeID = `${kindID}:${memberTypeID}`;\n stack.pop();\n return typeID;\n });\n}\n\n// ########## Load Composable Functions ##########\n"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"baseRunTypes.js","sources":["../../../../src/lib/baseRunTypes.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars /\n/ ########\n * 2024 mion\n * Author: Ma-jerez\n * License: MIT\n * The software is provided \"as is\", without warranty of any kind.\n * ######## /\nimport {MAX_STACK_DEPTH, JitCompiledFn, createUniqueHash, getJitUtils, getENV} from '@mionjs/core';\nimport type {\n RunType,\n Mutable,\n RunTypeChildAccessor,\n JitFnID,\n SrcType,\n SrcCollection,\n CustomVλl,\n JitFn,\n JitCode,\n RunTypeOptions,\n StrNumber,\n DeepPartial,\n RunTypeFamily,\n} from '../types.ts';\nimport type {mockType} from '../mocking/mockType.ts';\nimport {maxStackErrorMessage} from '../constants.ts';\nimport {type CodeType, JitFunctions, CodeTypes} from '../constants.functions.ts';\nimport {ReflectionKind, stringifyType} from '@deepkit/type';\nimport type {TypeIndexSignature, TypeProperty, Type} from '@deepkit/type';\nimport {getPropIndex, memorize} from './utils.ts';\nimport {createJitCompiler, MockJitCompiler} from './jitFnCompiler.ts';\nimport {getJITFnHash} from './createJitFunction.ts';\nimport type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';\nimport {type AnyKindName, getReflectionName} from '../constants.kind.ts';\nimport {initFormatAnnotations} from './formats.ts';\nimport {createTypeId} from './typeId.ts';\nimport {getJitFunctionCompiler, registerJitFunctionCompiler} from './jitFnsRegistry.ts';\nimport {defaultMockOptions} from '../mocking/constants.mock.ts';\n\nconst RB = CodeTypes.returnBlock;\nconst S = CodeTypes.statement;\nconst E = CodeTypes.expression;\n\nexport abstract class BaseRunType<T extends Type = Type> implements RunType {\n isCircular?: boolean;\n readonly src: SrcType<T> = null as any; // real value will be set after construction by the createRunType function\n abstract getFamily(): RunTypeFamily; // Atomic, Collection, Member, Function\n /\n This single functions controls whether or not the code for a type should be inlined into the parent function\n * or should create a separate jit function for it, add as a dependency and call it.\n * @returns\n /\n isJitInlined = (): boolean => {\n // if is circular, always create a separate jit function as need to self invoke\n if (this.isCircular) return false;\n if (getENV('DEBUG_JIT') === 'INLINED') return true;\n // all array are self invoked for isType and are usually repeated type like string[] or number[] so worth deduplicating\n if (this.src.kind === ReflectionKind.array) return false;\n // collection with name might be used in different places so worth deduplicating\n if (this.src.typeName && this.getFamily() === 'C') return false;\n return true;\n };\n getKindName = memorize((): AnyKindName => getReflectionName(this));\n getTypeName = (): string => this.src.typeName \|\| this.getKindName();\n stringify = memorize((): string => stringifyType(this.src));\n skipJit(comp: JitFnCompiler): boolean {\n return false;\n }\n /* Returns the format portion of the type ID (cached in src._formatId), or undefined if no format. /\n getFormatTypeID(): string \| undefined {\n // _formatId is cached by computeDeepkitFormatID during getDeepkitTypeId call\n // Empty string means no format, undefined means not computed yet\n const formatId = (this.src as any)._formatId;\n return formatId \|\| undefined;\n }\n /* Returns the type ID which is cached in src._typeId by getDeepkitTypeId(). Format ID is already included. /\n getTypeID(): StrNumber {\n if (this.src._typeId === undefined) {\n throw new Error(`Missing cached type ID for ${this.getTypeName()}. Ensure getDeepkitTypeId() has been called.`);\n }\n return this.src._typeId;\n }\n getJitHash(opts: RunTypeOptions): string {\n const optsCopy = {...opts};\n // remove mock options as not relevant for jit functionality\n if (optsCopy.mock) delete optsCopy.mock;\n return createUniqueHash(this.getTypeID().toString() + JSON.stringify(optsCopy));\n }\n getParent = (): BaseRunType \| undefined => (this.src.parent as SrcType)?._rt as BaseRunType;\n checkIsCircularAndGetRefId(stack: RunType[] = []): StrNumber \| undefined {\n const inStackIndex = stack.findIndex((rt) => {\n if (rt === this) return true;\n // some nodes seems to be different objects in memory but are the same id, so we check by id as well\n return rt.src.id && this.src.id && rt.src.id === this.src.id;\n }); // cant use isSameJitType because it uses getTypeID and would loop forever\n const inStackSrcId = stack.findIndex((rt) => rt.src.id && this.src.id && rt.src.id === this.src.id);\n const isInStack = inStackIndex >= 0; // recursive reference\n if (isInStack) {\n this.isCircular = true;\n const name = this.src.typeName \|\| ''; // todo: not sure if all the circular references will have a name\n const refId = '$' + this.src.kind + `_${inStackIndex}` + name; // ensures different circular types have different typeID\n return refId;\n }\n return undefined;\n }\n /\n Method that should be called Immediately after the RunType gets created to link the SrcType and RunType.\n * This is more flexible than passing params to the constructor helps to avoid circular dependencies, etc.\n * /\n onCreated(src: SrcType<any>): void {\n (this as Mutable<RunType>).src = src;\n (src as Mutable<SrcType>)._rt = this;\n initFormatAnnotations(this);\n // Cache the type ID on the src object - this includes format information\n createTypeId(src);\n }\n /\n Some elements might need a standalone name variable that ignores the vλl value of the parents.\n * returns a variable that is being compiled, ignores the parents variable names /\n getCustomVλl(comp: JitFnCompiler): CustomVλl \| undefined {\n return undefined;\n }\n /\n Some elements might need a custom static path to be able to reference the source of an error.\n * ie: when validating a Map we need to differentiate if the value that failed is the key or the value of a map's entry.\n /\n getStaticPathLiteral(comp: JitFnCompiler): string \| number \| undefined {\n return undefined;\n }\n\n // ########## Mock ##########\n\n async mock(opts?: DeepPartial<RunTypeOptions>): Promise<any> {\n // although the mock function is not jit, it is also stored in the registry\n // this is because we don't want to load mock related functionality if not needed\n await registerJitFunctionCompiler(JitFunctions.mock);\n return this.mockType(opts);\n }\n\n /* synchronous version of mock, throws an error if the mock function has not been loaded /\n mockType(opts: DeepPartial<RunTypeOptions> = {}): any {\n const mockFn = getJitFunctionCompiler(JitFunctions.mock) as typeof mockType;\n if (!mockFn)\n throw new Error(\n `Function ${JitFunctions.mock.name} has not been loaded. make sure you have called loadJitCompilerFunction(JitFunctions.mock) before calling mockType.`\n );\n const fnID = JitFunctions.mock.id;\n // options sent to the compiler will be set to empty as mock options are handled separately from the compiler\n const mockingOpts = {...opts, mock: {...defaultMockOptions, ...(opts.mock \|\| {})}} as RunTypeOptions;\n const hash = getJITFnHash(fnID, this, mockingOpts);\n const comp = new MockJitCompiler(this, mockingOpts, undefined, hash, this.getTypeID());\n return mockFn(this, comp);\n }\n\n // ########## Create Jit Functions ##########\n\n createJitFunction = (jitFn: JitFn, opts: RunTypeOptions = {}): ((...args: any[]) => any) => {\n return this.createJitCompiledFunction(jitFn.id, undefined, opts).fn;\n };\n\n createJitCompiledFunction(fnID: JitFnID, parentCop?: JitFnCompiler, opts: RunTypeOptions = {}): JitCompiledFn {\n const fnHash = getJITFnHash(fnID, this, opts);\n const jitCompiled = getJitUtils().getJIT(fnHash);\n if (jitCompiled) {\n if (getENV('DEBUG_JIT') === 'VERBOSE')\n console.log(`\\x1b[32m Using cached function: ${jitCompiled.jitFnHash} \\x1b[0m`);\n return jitCompiled;\n }\n const newJitCompiler: JitFnCompiler = createJitCompiler(\n this,\n fnID,\n parentCop,\n undefined,\n undefined,\n opts\n ) as JitFnCompiler;\n try {\n const codeType = this.getFamily() === 'A' ? E : S;\n newJitCompiler.compile(this, codeType, fnID);\n newJitCompiler.createJitFunction();\n } catch (e: any) {\n // if something goes wrong during compilation we want to remove the compiler from\n // the cache as this is automatically added to jitUtils cache during compilation\n newJitCompiler.removeFromJitCache();\n // TODO: we need to print the full path to the type that is causing the error\n // for this ideally we should add a parent Compiler and print the trace only from the root\n if (typeof e?.message === 'string' && !newJitCompiler.hasStackTrace(e.message))\n e.message += newJitCompiler.getStackTrace();\n throw e;\n }\n return newJitCompiler as JitCompiledFn;\n }\n\n // ########## emit Methods that generates src code ##########\n\n abstract emitIsType(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitTypeErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitHasUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitUnknownKeyErrors(comp: JitErrorsFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitStripUnknownKeys(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitUnknownKeysToUndefined(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n // todo: maybe we should move these two into a single file like the rest of serializers\n abstract emitPrepareForJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n abstract emitRestoreFromJson(comp: JitFnCompiler, expectedCType: CodeType): JitCode;\n}\n\n/\n RunType that is atomic an does not contains any other child runTypes.\n * ie: string, number, boolean, any, null, undefined, void, never, bigint, etc.\n * /\nexport abstract class AtomicRunType<T extends Type> extends BaseRunType<T> {\n getFamily(): 'A' {\n return 'A';\n }\n emitPrepareForJson(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitRestoreFromJson(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: E};\n }\n emitUnknownKeyErrors(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n return {code: undefined, type: S};\n }\n}\n\n/\n RunType that contains a collection or child runTypes.\n * Collection RunTypes are the only ones that can have circular references. as a child of a collection RunType can be the parent of the collection RunType.\n * i.e: interface, child runTypes are it's properties\n * i.e: tuple, it's child runTypes are the tuple members\n /\nexport abstract class CollectionRunType<T extends Type> extends BaseRunType<T> {\n getFamily(): 'C' {\n return 'C';\n }\n getChildRunTypes = (): BaseRunType[] => {\n const childTypes = ((this.src as SrcCollection).types as SrcType[]) \|\| []; // deepkit stores child types in the types property\n return childTypes.map((t) => t._rt as BaseRunType);\n };\n getJitChildren(comp: JitFnCompiler): BaseRunType[] {\n let skipIndex = false; // if there are multiple index signatures, only the first one will be used as they must be same type just different keys\n return this.getChildRunTypes().filter((c) => {\n if (c.skipJit(comp)) return false;\n const isIndex = c.src.kind === ReflectionKind.indexSignature;\n if (isIndex && skipIndex) return false;\n if (isIndex) skipIndex = true;\n return true;\n });\n }\n areAllChildrenOptional(children: BaseRunType[]) {\n return children.every(\n (prop) =>\n (prop as MemberRunType<any>)?.isOptional() \|\|\n (prop.src as TypeProperty)?.optional \|\|\n prop.src.kind === ReflectionKind.indexSignature\n );\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileHasUnknownKeys(c, E).code)\n .filter((code) => !!code);\n return {code: codes.join(' \|\| '), type: E};\n }\n emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileUnknownKeyErrors(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileStripUnknownKeys(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n const codes = this.getJitChildren(comp)\n .map((c) => comp.compileUnknownKeysToUndefined(c, S).code)\n .filter((code) => !!code);\n return {code: codes.join(';'), type: S};\n }\n}\n\n/\n RunType that contains a single member or child RunType. usually part of a collection RunType.\n * i.e object properties, {prop: memberType} where memberType is the child RunType\n /\nexport abstract class MemberRunType<T extends Type> extends BaseRunType<T> implements RunTypeChildAccessor {\n abstract isOptional(): boolean;\n abstract getChildVarName(comp: JitFnCompiler): string \| number;\n abstract getChildLiteral(comp: JitFnCompiler): string \| number;\n abstract useArrayAccessor(): boolean;\n /* used to compile json stringify /\n skipCommas?: boolean;\n /* used to compile json stringify */\n tempChildVλl?: string;\n getFamily(): 'M' {\n return 'M';\n }\n getMemberType(): BaseRunType {\n const memberType = (this.src as any).type as SrcType; // deepkit stores member types in the type property\n return memberType._rt as BaseRunType;\n }\n getChildIndex(comp: JitFnCompiler) {\n const start = comp?.opts?.paramsSlice?.start;\n if (start) return getPropIndex(this.src) - start;\n return getPropIndex(this.src);\n }\n getJitChild(comp: JitFnCompiler): BaseRunType \| undefined {\n const member: BaseRunType = this.getMemberType();\n if (member.skipJit(comp)) return undefined;\n return member;\n }\n emitHasUnknownKeys(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileHasUnknownKeys(child, E);\n if (!codeResult?.code) return {code: undefined, type: E};\n const childName = comp.getChildVλl();\n const finalCode = this.isOptional() ? `(${childName} !== undefined && ${codeResult.code})` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitUnknownKeyErrors(comp: JitErrorsFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileUnknownKeyErrors(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitStripUnknownKeys(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileStripUnknownKeys(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n emitUnknownKeysToUndefined(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const codeResult = comp.compileUnknownKeysToUndefined(child, S);\n if (!codeResult?.code) return {code: undefined, type: S};\n const finalCode = this.isOptional() ? `if (${comp.getChildVλl()} !== undefined) {${codeResult.code}}` : codeResult.code;\n return {code: finalCode, type: codeResult.type};\n }\n visitToBinary(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const code = comp.compileToBinary(child, S);\n if (!code?.code) return {code: undefined, type: S};\n return this.isOptional()\n ? {code: `(${comp.getChildVλl()} !== undefined ? ${code.code} : utl.writeBinaryNull())`, type: S}\n : code;\n }\n visitFromBinary(comp: JitFnCompiler): JitCode {\n const child = this.getJitChild(comp);\n const code = comp.compileFromBinary(child, S);\n if (!code?.code) return {code: undefined, type: S};\n return code;\n }\n}\n\n// ########## Load Composable Functions ##########\n"],"names":[],"mappings":"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"}

package/.dist/esm/src/lib/jitFnCompiler.d.ts CHANGED Viewed

@@ -30,8 +30,8 @@ export declare class BaseFnCompiler<FnArgsNames extends JitFnArgs = JitFnArgs, I
     readonly code: string;
     readonly contextCodeItems: Map<string, string>;
     readonly isNoop?: boolean;
-    readonly jitDependencies: Array<string>;
-    readonly pureFnDependencies: Array<string>;
+    readonly jitDependencies: Array<string> | undefined;
+    readonly pureFnDependencies: Array<string> | undefined;
     readonly stack: StackItem[];
     popItem: StackItem | undefined;
     get length(): number;

package/.dist/esm/src/lib/jitFnCompiler.js CHANGED Viewed

@@ -57,8 +57,8 @@ class BaseFnCompiler {
    */
   isNoop = false;
   /** The list of all jit functions that are used by this function and it's children. */
-  jitDependencies = [];
-  pureFnDependencies = [];
+  jitDependencies;
+  pureFnDependencies;
   /** The list of types being compiled.*/
   stack = [];
   popItem;
@@ -179,7 +179,8 @@ ${fnCode}`);
   }
   updateDependencies(childComp) {
     if (childComp.isNoop) return;
-    if (this.jitDependencies.includes(childComp.jitFnHash)) return;
+    if (this.jitDependencies?.includes(childComp.jitFnHash)) return;
+    if (!this.jitDependencies) this.jitDependencies = [];
     this.jitDependencies.push(childComp.jitFnHash);
   }
   removeFromJitCache() {
@@ -496,7 +497,8 @@ ${fnCode}`);
         `Pure function with name ${fnName} can not be added as jit dependency in namespace ${namespace}, be sure to register the pure function first by calling getJitUtils().addPureFn()`
       );
     const key = `${namespace}::${fnName}`;
-    if (this.pureFnDependencies.includes(key)) return;
+    if (this.pureFnDependencies?.includes(key)) return;
+    if (!this.pureFnDependencies) this.pureFnDependencies = [];
     this.pureFnDependencies.push(key);
   }
 }