@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/jitCompilers/json/stringifyJson.cjs

@@ -0,0 +1,399 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_constants_kind = require("../../constants.kind.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_runTypesPureFns = require("../../run-types-pure-fns.cjs");
+function createStringifyCompiler(fnID) {
+  const compileStringifyIterable = createStringifyIterable(fnID);
+  function compileStringify(runType, comp) {
+    const src = runType.src;
+    const kind = src.kind;
+    switch (kind) {
+      // ###################### ATOMIC RUNTYPES ######################
+      // Primitive types and other atomic types that don't contain other types
+      case type.ReflectionKind.unknown:
+      case type.ReflectionKind.any:
+        return { code: `JSON.stringify(${comp.vλl})`, type: "E" };
+      case type.ReflectionKind.bigint:
+        return { code: `'"'+${comp.vλl}.toString()+'"'`, type: "E" };
+      case type.ReflectionKind.boolean:
+        return { code: `(${comp.vλl} ? 'true' : 'false')`, type: "E" };
+      case type.ReflectionKind.enum:
+        if (src.indexType.kind === type.ReflectionKind.number) return { code: comp.vλl, type: "E" };
+        return { code: `JSON.stringify(${comp.vλl})`, type: "E" };
+      case type.ReflectionKind.enumMember:
+        throw new Error("StringifyJson enum member is not supported.");
+      case type.ReflectionKind.literal: {
+        const rt = runType;
+        if (src.literal instanceof RegExp) return compileStringify({ src: { kind: type.ReflectionKind.regexp } }, comp);
+        const literalRt = runType;
+        const originalKind = src.kind;
+        let result;
+        switch (typeof rt.src.literal) {
+          case "number":
+            literalRt.src.kind = type.ReflectionKind.number;
+            result = compileStringify(literalRt, comp);
+            break;
+          case "string":
+            literalRt.src.kind = type.ReflectionKind.string;
+            result = compileStringify(literalRt, comp);
+            break;
+          case "boolean":
+            literalRt.src.kind = type.ReflectionKind.boolean;
+            result = compileStringify(literalRt, comp);
+            break;
+          case "bigint":
+            literalRt.src.kind = type.ReflectionKind.bigint;
+            result = compileStringify(literalRt, comp);
+            break;
+          case "symbol":
+            literalRt.src.kind = type.ReflectionKind.symbol;
+            result = compileStringify(literalRt, comp);
+            break;
+          default:
+            result = { code: `JSON.stringify(${comp.vλl})`, type: "E" };
+            break;
+        }
+        literalRt.src.kind = originalKind;
+        return result;
+      }
+      case type.ReflectionKind.never:
+        throw new Error("Never type cannot be stringified.");
+      case type.ReflectionKind.null: {
+        const isRoot = comp.getNestLevel(runType) === 0;
+        return { code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: "E" };
+      }
+      case type.ReflectionKind.number: {
+        const isRoot = comp.getNestLevel(runType) === 0;
+        return { code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: "E" };
+      }
+      case type.ReflectionKind.object:
+        return { code: `JSON.stringify(${comp.vλl})`, type: "E" };
+      case type.ReflectionKind.regexp: {
+        return { code: `JSON.stringify(${comp.vλl}.toString())`, type: "E" };
+      }
+      case type.ReflectionKind.string: {
+        return { code: `JSON.stringify(${comp.vλl})`, type: "E" };
+      }
+      case type.ReflectionKind.symbol:
+        return { code: `JSON.stringify('Symbol:' + (${comp.vλl}.description || ''))`, type: "E" };
+      case type.ReflectionKind.templateLiteral:
+        throw new Error("Template Literals are not supported.");
+      case type.ReflectionKind.undefined: {
+        const isRoot = comp.getNestLevel(runType) === 0;
+        if (isRoot) return { code: `undefined`, type: "E" };
+        const parentIsArray = src_lib_utils.parentIs(runType, type.ReflectionKind.array);
+        if (parentIsArray) return { code: `'null'`, type: "E" };
+        return { code: `null`, type: "E" };
+      }
+      case type.ReflectionKind.void:
+        return { code: "undefined", type: "E" };
+      // ###################### MEMBER RUNTYPES ######################
+      // Types that represent members of collections or other structures
+      case type.ReflectionKind.array: {
+        const rt = runType;
+        rt.checkNonSkipTypes(comp);
+        const childJit = comp.compile(rt.getJitChild(comp), "E", fnID);
+        if (!childJit?.code) return { code: `JSON.stringify(${comp.vλl})`, type: "RB" };
+        const jsonItems = comp.getLocalVarName("ls", rt);
+        const resultVal = comp.getLocalVarName("res", rt);
+        const index = rt.getChildVarName(comp);
+        return {
+          code: `
+                const ${jsonItems} = [];
+                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                    const ${resultVal} = ${childJit.code};
+                    ${jsonItems}.push(${resultVal});
+                }
+                return '[' + ${jsonItems}.join(',') + ']';
+            `,
+          type: "RB"
+        };
+      }
+      case type.ReflectionKind.indexSignature: {
+        const rt = runType;
+        const child = rt.getJitChild(comp);
+        const childJit = comp.compile(child, "E", fnID);
+        if (!child || !childJit?.code) return { code: void 0, type: "RB" };
+        const varName = comp.vλl;
+        const prop = rt.getChildVarName(comp);
+        const arrName = comp.getLocalVarName("ls", rt);
+        const sep = rt.skipCommas ? "" : '+","';
+        const skipCode = rt.getSkipCode(comp, prop);
+        const asJSONStringFn = comp.addPureFunction(src_runTypesPureFns.cpf_asJSONString);
+        return {
+          code: `
+                const ${arrName} = [];
+                for (const ${prop} in ${varName}) {
+                    ${skipCode}
+                    if (${prop} !== undefined) ${arrName}.push(${asJSONStringFn}(${prop}) + ':' + ${childJit.code});
+                }
+                if (!${arrName}.length) return '';
+                return ${arrName}.join(',')${sep};
+            `,
+          type: "RB"
+        };
+      }
+      case type.ReflectionKind.function:
+      case type.ReflectionKind.method:
+      case type.ReflectionKind.methodSignature:
+      case type.ReflectionKind.callSignature:
+        if (runType.src.subKind === src_constants_kind.ReflectionSubKind.params) {
+          const rt = runType;
+          const skip = rt.skipJit(comp);
+          if (skip) return { code: "", type: "E" };
+          const params = rt.getParamRunTypes(comp);
+          if (params.length === 0) return { code: `'[]'`, type: "E" };
+          const paramsCode = params.map((p) => comp.compile(p, "E", fnID).code).join("+");
+          return { code: `'['+${paramsCode}+']'`, type: "E" };
+        } else {
+          throw new Error(
+            `Compile function ${getOperationName()} not supported, call compileParams or compileReturn instead.`
+          );
+        }
+      case type.ReflectionKind.parameter: {
+        const rt = runType;
+        switch (src.subKind) {
+          case src_constants_kind.ReflectionSubKind.mapKey:
+          case src_constants_kind.ReflectionSubKind.mapValue:
+          case src_constants_kind.ReflectionSubKind.setItem:
+            return compileStringifyGenericMember(rt, comp);
+          default:
+            return compileStringifyParameter(rt, comp);
+        }
+      }
+      case type.ReflectionKind.property:
+      case type.ReflectionKind.propertySignature: {
+        const rt = runType;
+        const child = rt.getJitChild(comp);
+        const childJit = comp.compile(child, "E", fnID);
+        if (!child || !childJit?.code) return { code: void 0, type: "E" };
+        const sep = rt.skipCommas ? "" : '+","';
+        const propDef = getPropName(rt, comp);
+        if (rt.src.optional) {
+          rt.tempChildVλl = comp.getChildVλl();
+          return { code: `(${rt.tempChildVλl} === undefined ? '' : ${propDef}+${childJit.code}${sep})`, type: "E" };
+        }
+        return { code: `${propDef}+${childJit.code}${sep}`, type: "E" };
+      }
+      case type.ReflectionKind.rest: {
+        const rt = runType;
+        const childJit = comp.compile(rt.getJitChild(comp), "E", fnID);
+        const itemCodeStr = childJit?.code || "JSON.stringify(" + comp.getChildVλl() + ")";
+        const arrName = comp.getLocalVarName("res", rt);
+        const itemName = comp.getLocalVarName("its", rt);
+        const index = rt.getChildVarName(comp);
+        const isFist = rt.getChildIndex(comp) === 0;
+        const sep = isFist ? "" : `','+`;
+        return {
+          code: `
+                const ${arrName} = [];
+                for (let ${index} = ${rt.getChildIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {
+                    const ${itemName} = ${itemCodeStr};
+                    if(${itemName}) ${arrName}.push(${itemName});
+                }
+                if (!${arrName}.length) {return '';}
+                else {return ${sep}${arrName}.join(',')}
+            `,
+          type: "RB"
+        };
+      }
+      case type.ReflectionKind.tupleMember: {
+        const rt = runType;
+        const childJit = comp.compile(rt.getJitChild(comp), "E", fnID);
+        const childCodeStr = childJit?.code || `null`;
+        if (rt.isRest()) return childJit || { code: `null`, type: "E" };
+        const isFirst = rt.getChildIndex(comp) === 0;
+        const sep = isFirst ? "" : `','+`;
+        if (rt.isOptional())
+          return { code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: "E" };
+        return { code: `${sep}${childCodeStr}`, type: "E" };
+      }
+      case type.ReflectionKind.promise: {
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+      }
+      // ###################### COLLECTION RUNTYPES ######################
+      // Types that contain other types as members
+      case type.ReflectionKind.objectLiteral:
+      case type.ReflectionKind.intersection: {
+        if (runType.src.subKind === src_constants_kind.ReflectionSubKind.nonSerializable) {
+          throw new Error(`${getOperationName()} is disabled for Non Serializable types.`);
+        } else {
+          const rt = runType;
+          return compileStringifyInterface(rt, comp);
+        }
+      }
+      case type.ReflectionKind.class:
+        return compileStringifyClass(runType, comp);
+      case type.ReflectionKind.infer:
+        throw new Error("Infer is not supported.");
+      case type.ReflectionKind.tuple: {
+        const rt = runType;
+        const skip = rt.skipJit(comp);
+        if (skip) return { code: "", type: "E" };
+        if (rt.getChildRunTypes().length === 0) return { code: `'[]'`, type: "E" };
+        const paramsCode = rt.getChildRunTypes().map((p) => comp.compile(p, "E", fnID).code).join("+");
+        return { code: `'['+${paramsCode}+']'`, type: "E" };
+      }
+      case type.ReflectionKind.typeParameter:
+        throw new Error("Type parameter not implemented.");
+      case type.ReflectionKind.union: {
+        const urt = runType;
+        urt.checkAllowedChildren(comp);
+        const { simpleItems, objectTypes, anyItem } = urt.getUnionChildren(comp);
+        const errName = comp.getLocalVarName("uErr", urt);
+        const fail = `throw new Error(${errName});`;
+        comp.setContextItem(
+          errName,
+          `const ${errName} = "Can not ${getOperationName()} union: item does not belong to the union"`
+        );
+        const ifElse = src_lib_utils.createIfElseFn();
+        const getStringifyCode = (unionItem) => {
+          const childJit = comp.compile(unionItem, "E", fnID);
+          const encJit = comp.compilePrepareForJson(unionItem, "E");
+          const decJit = comp.compileRestoreFromJson(unionItem, "E");
+          const needsTupleEncoding = !!encJit?.code || !!decJit?.code;
+          const skiEncode = !childJit?.code || childJit.code === comp.vλl;
+          const stringifyCode = skiEncode ? comp.vλl : childJit.code;
+          const index = urt.getUnionItemIndex(comp, unionItem);
+          const toTuple = `'[${index},' + ${stringifyCode} + ']'`;
+          const tupleCode = unionItem.getFamily() === "A" ? `(${toTuple})` : toTuple;
+          return needsTupleEncoding ? `return ${tupleCode}` : `return ${stringifyCode}`;
+        };
+        const simpleCode = simpleItems.map((unionItem) => {
+          const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);
+          return `${ifElse()} (${isTypeCode}) {${getStringifyCode(unionItem)}}`;
+        });
+        const objCode = objectTypes.length ? objectTypes.map((unionItem) => {
+          const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);
+          return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getStringifyCode(unionItem)}}`;
+        }) : [];
+        const anyCode = anyItem ? `${ifElse(true)} {${getStringifyCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;
+        return { code: [...simpleCode, ...objCode, anyCode].join(""), type: "RB" };
+      }
+      default:
+        throw new Error(`Cant ${getOperationName()} for unsupported RunType: ${runType.getTypeName()}`);
+    }
+  }
+  function getOperationName() {
+    switch (fnID) {
+      case src_constants_functions.JitFunctions.stringifyJson.id:
+        return "StringifyJson";
+      case src_constants_functions.JitFunctions.toJSCode.id:
+        return "ToCode";
+      default:
+        throw new Error(`Unknown operation: ${fnID}`);
+    }
+  }
+  function getPropName(rt, comp) {
+    if (!src_lib_utils.isSafePropName(rt.src.name)) return `${JSON.stringify(rt.getChildLiteral(comp))}+':'`;
+    if (fnID === src_constants_functions.JitFunctions.toJSCode.id) return `'${rt.getChildVarName(comp)}:'`;
+    return `'"${rt.getChildVarName(comp)}":'`;
+  }
+  function compileStringifyParameter(rt, comp) {
+    const childJit = comp.compile(rt.getJitChild(comp), "E", fnID);
+    const childCodeStr = childJit?.code || `null`;
+    if (rt.isRest()) return childJit || { code: `null`, type: "E" };
+    const isFirst = rt.getChildIndex(comp) === 0;
+    const sep = isFirst ? "" : `','+`;
+    if (rt.isOptional())
+      return { code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: "E" };
+    return { code: `${sep}${childCodeStr}`, type: "E" };
+  }
+  function compileStringifyGenericMember(rt, comp) {
+    const child = rt.getJitChild(comp);
+    const argCode = comp.compile(child, "E", fnID);
+    if (!argCode?.code) return { code: void 0, type: "E" };
+    const isFirst = rt.getChildIndex(comp) === 0;
+    const sep = isFirst ? "" : `','+`;
+    if (rt.isOptional()) return { code: `(${comp.getChildVλl()} === undefined ? '': ${sep}${argCode.code})`, type: "E" };
+    return { code: `${sep}${argCode.code}`, type: "E" };
+  }
+  function compileStringifyInterface(rt, comp) {
+    if (rt.isCallable()) return comp.compile(rt.getCallSignature(), "E", fnID);
+    const children = rt.getJsonStringifySortedChildren(comp);
+    if (children.length === 0) return { code: `''`, type: "E" };
+    const allOptional = children.every((prop) => prop.isOptional());
+    if (allOptional) return compileInterfaceIntoArray(rt, comp, children);
+    const childrenCode = children.map((prop, i) => {
+      const nexChild = children[i + 1];
+      const isLast = !nexChild;
+      prop.skipCommas = isLast;
+      return comp.compile(prop, "E", fnID).code;
+    }).filter(Boolean).join("+");
+    return { code: `'{'+${childrenCode}+'}'`, type: "E" };
+  }
+  function compileInterfaceIntoArray(rt, comp, children) {
+    const arrName = comp.getLocalVarName("ns", rt);
+    const childrenCode = children.map((prop) => {
+      prop.skipCommas = true;
+      const childJit = comp.compile(prop, "E", fnID);
+      if (!childJit?.code) return "";
+      const code = `${arrName}.push(${childJit.code})`;
+      return prop.isOptional() && prop.tempChildVλl ? `if (${prop.tempChildVλl} !== undefined){${code}}` : `${code};`;
+    }).filter(Boolean).join("");
+    return { code: `(function(){const ${arrName} = [];${childrenCode};return '{'+${arrName}.join(',')+'}'})()`, type: "E" };
+  }
+  function compileStringifyClass(runType, comp) {
+    switch (runType.src.subKind) {
+      case src_constants_kind.ReflectionSubKind.date:
+        return { code: `'"'+${comp.vλl}.toJSON()+'"'`, type: "E" };
+      case src_constants_kind.ReflectionSubKind.map: {
+        const rt = runType;
+        return compileStringifyIterable(rt, comp);
+      }
+      case src_constants_kind.ReflectionSubKind.set: {
+        const rt = runType;
+        return compileStringifyIterable(rt, comp);
+      }
+      case src_constants_kind.ReflectionSubKind.nonSerializable:
+        throw new Error(`Jit compilation disabled for Non Serializable types.`);
+      default: {
+        const rt = runType;
+        if (rt.isCallable()) {
+          const callSignature = rt.getCallSignature();
+          if (callSignature) return comp.compile(callSignature, "E", fnID);
+        }
+        const children = rt.getJsonStringifySortedChildren(comp);
+        if (children.length === 0) return { code: `''`, type: "E" };
+        const childrenCode = children.map((prop, i) => {
+          const nexChild = children[i + 1];
+          const isLast = !nexChild;
+          prop.skipCommas = isLast;
+          return comp.compile(prop, "E", fnID).code;
+        }).filter(Boolean).join("+");
+        return { code: `'{'+${childrenCode}+'}'`, type: "E" };
+      }
+    }
+  }
+  return compileStringify;
+}
+function createStringifyIterable(fnID) {
+  return function compileStringifyIterable(rt, comp, codePrefix = "", codeSuffix = "") {
+    const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;
+    const jitChildren = rt.getJitChildren(comp);
+    const childrenCode = jitChildren.map((c) => comp.compile(c, "E", fnID).code).join("+");
+    const jsonItems = comp.getLocalVarName("ls", rt);
+    const resultVal = comp.getLocalVarName("res", rt);
+    const childrenResult = jitChildren.length > 1 ? `'['+${childrenCode}+']'` : childrenCode;
+    const earlyReturn = codePrefix && codeSuffix ? `if (!${jsonItems}.length) return '${codePrefix}${codeSuffix}';` : "";
+    return {
+      code: `
+        const ${jsonItems} = [];
+        for (const ${entry} of ${comp.vλl}) {
+            const ${resultVal} = ${childrenResult};
+            ${jsonItems}.push(${resultVal});
+        }
+        ${earlyReturn}return '${codePrefix}[' + ${jsonItems}.join(',') + ']${codeSuffix}'
+    `,
+      type: "RB"
+    };
+  };
+}
+const emitJsonStringify = createStringifyCompiler(src_constants_functions.JitFunctions.stringifyJson.id);
+exports.createStringifyCompiler = createStringifyCompiler;
+exports.createStringifyIterable = createStringifyIterable;
+exports.emitJsonStringify = emitJsonStringify;
+//# sourceMappingURL=stringifyJson.cjs.map

package/.dist/cjs/src/jitCompilers/json/stringifyJson.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyJson.cjs","sources":["../../../../../src/jitCompilers/json/stringifyJson.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 {ReflectionKind} from '@deepkit/type';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {JitFunctions} from '../../constants.functions.ts';\nimport {JitFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport {createIfElseFn, isSafePropName, parentIs} from '../../lib/utils.ts';\nimport type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';\nimport type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport type {ClassRunType} from '../../nodes/collection/class.ts';\nimport type {PropertyRunType} from '../../nodes/member/property.ts';\nimport type {MapRunType} from '../../nodes/native/map.ts';\nimport type {SetRunType} from '../../nodes/native/set.ts';\nimport type {InterfaceRunType} from '../../nodes/collection/interface.ts';\nimport type {TupleRunType} from '../../nodes/collection/tuple.ts';\nimport type {FunctionParamsRunType} from '../../nodes/collection/functionParams.ts';\nimport type {UnionRunType} from '../../nodes/collection/union.ts';\nimport type {ParameterRunType} from '../../nodes/member/param.ts';\nimport type {RestParamsRunType} from '../../nodes/member/restParams.ts';\nimport type {ArrayRunType} from '../../nodes/member/array.ts';\nimport type {MemberRunType} from '../../lib/baseRunTypes.ts';\nimport type {LiteralRunType} from '../../nodes/atomic/literal.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport {cpf_asJSONString} from '../../run-types-pure-fns.ts';\n\ntype Operation = typeof JitFunctions.stringifyJson.id | typeof JitFunctions.toJSCode.id;\n\nexport function createStringifyCompiler(fnID: Operation) {\n    const compileStringifyIterable = createStringifyIterable(fnID);\n    /** Centralized compile jit function with a switch statement that handles all node types. */\n    function compileStringify(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n        const src = runType.src;\n        const kind = src.kind;\n\n        switch (kind) {\n            // ###################### ATOMIC RUNTYPES ######################\n            // Primitive types and other atomic types that don't contain other types\n            case ReflectionKind.unknown:\n            case ReflectionKind.any:\n                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};\n            case ReflectionKind.bigint:\n                return {code: `'\"'+${comp.vλl}.toString()+'\"'`, type: 'E'};\n            case ReflectionKind.boolean:\n                return {code: `(${comp.vλl} ? 'true' : 'false')`, type: 'E'};\n            case ReflectionKind.enum:\n                if (src.indexType.kind === ReflectionKind.number) return {code: comp.vλl, type: 'E'};\n                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};\n            case ReflectionKind.enumMember:\n                throw new Error('StringifyJson enum member is not supported.');\n            case ReflectionKind.literal: {\n                const rt = runType as LiteralRunType;\n                if (src.literal instanceof RegExp) return compileStringify({src: {kind: ReflectionKind.regexp}} as any, comp);\n                const literalRt = runType;\n                const originalKind = src.kind;\n                let result: JitCode;\n                switch (typeof rt.src.literal) {\n                    case 'number':\n                        literalRt.src.kind = ReflectionKind.number;\n                        result = compileStringify(literalRt, comp);\n                        break;\n                    case 'string':\n                        literalRt.src.kind = ReflectionKind.string;\n                        result = compileStringify(literalRt, comp);\n                        break;\n                    case 'boolean':\n                        literalRt.src.kind = ReflectionKind.boolean;\n                        result = compileStringify(literalRt, comp);\n                        break;\n                    case 'bigint':\n                        literalRt.src.kind = ReflectionKind.bigint;\n                        result = compileStringify(literalRt, comp);\n                        break;\n                    case 'symbol':\n                        literalRt.src.kind = ReflectionKind.symbol;\n                        result = compileStringify(literalRt, comp);\n                        break;\n                    default:\n                        result = {code: `JSON.stringify(${comp.vλl})`, type: 'E'};\n                        break;\n                }\n                literalRt.src.kind = originalKind;\n                return result;\n            }\n            case ReflectionKind.never:\n                throw new Error('Never type cannot be stringified.');\n            case ReflectionKind.null: {\n                const isRoot = comp.getNestLevel(runType) === 0;\n                return {code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: 'E'};\n            }\n            case ReflectionKind.number: {\n                const isRoot = comp.getNestLevel(runType) === 0;\n                return {code: isRoot ? `String(${comp.vλl})` : comp.vλl, type: 'E'};\n            }\n            case ReflectionKind.object:\n                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};\n            case ReflectionKind.regexp: {\n                return {code: `JSON.stringify(${comp.vλl}.toString())`, type: 'E'};\n            }\n            case ReflectionKind.string: {\n                return {code: `JSON.stringify(${comp.vλl})`, type: 'E'};\n            }\n            case ReflectionKind.symbol:\n                return {code: `JSON.stringify('Symbol:' + (${comp.vλl}.description || ''))`, type: 'E'};\n            case ReflectionKind.templateLiteral:\n                throw new Error('Template Literals are not supported.');\n            case ReflectionKind.undefined: {\n                const isRoot = comp.getNestLevel(runType) === 0;\n                if (isRoot) return {code: `undefined`, type: 'E'};\n                const parentIsArray = parentIs(runType, ReflectionKind.array);\n                if (parentIsArray) return {code: `'null'`, type: 'E'}; // we use array.join(',') to serialize arrays, so we need to return null literal (string)\n                return {code: `null`, type: 'E'};\n            }\n            case ReflectionKind.void:\n                return {code: 'undefined', type: 'E'};\n\n            // ###################### MEMBER RUNTYPES ######################\n            // Types that represent members of collections or other structures\n            case ReflectionKind.array: {\n                const rt = runType as ArrayRunType;\n                rt.checkNonSkipTypes(comp);\n                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);\n                if (!childJit?.code) return {code: `JSON.stringify(${comp.vλl})`, type: 'RB'};\n                const jsonItems = comp.getLocalVarName('ls', rt);\n                const resultVal = comp.getLocalVarName('res', rt);\n                const index = rt.getChildVarName(comp);\n                return {\n                    code: `\n                const ${jsonItems} = [];\n                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {\n                    const ${resultVal} = ${childJit.code};\n                    ${jsonItems}.push(${resultVal});\n                }\n                return '[' + ${jsonItems}.join(',') + ']';\n            `,\n                    type: 'RB',\n                };\n            }\n            case ReflectionKind.indexSignature: {\n                const rt = runType as IndexSignatureRunType;\n                const child = rt.getJitChild(comp);\n                const childJit = comp.compile(child, 'E', fnID);\n                if (!child || !childJit?.code) return {code: undefined, type: 'RB'};\n                const varName = comp.vλl;\n                const prop = rt.getChildVarName(comp);\n                const arrName = comp.getLocalVarName('ls', rt);\n                const sep = rt.skipCommas ? '' : '+\",\"';\n                const skipCode = rt.getSkipCode(comp, prop);\n                // asJSONString is more optimized for propNames than JSON.stringify\n                // in Node, bun is actually slower so we might consider removing this and use native JSON.stringify\n                const asJSONStringFn = comp.addPureFunction(cpf_asJSONString);\n                return {\n                    code: `\n                const ${arrName} = [];\n                for (const ${prop} in ${varName}) {\n                    ${skipCode}\n                    if (${prop} !== undefined) ${arrName}.push(${asJSONStringFn}(${prop}) + ':' + ${childJit.code});\n                }\n                if (!${arrName}.length) return '';\n                return ${arrName}.join(',')${sep};\n            `,\n                    type: 'RB',\n                };\n            }\n            case ReflectionKind.function:\n            case ReflectionKind.method:\n            case ReflectionKind.methodSignature:\n            case ReflectionKind.callSignature:\n                if (runType.src.subKind === ReflectionSubKind.params) {\n                    const rt = runType as FunctionParamsRunType;\n                    const skip = rt.skipJit(comp);\n                    if (skip) return {code: '', type: 'E'};\n                    const params = rt.getParamRunTypes(comp);\n                    if (params.length === 0) return {code: `'[]'`, type: 'E'};\n                    const paramsCode = params.map((p) => comp.compile(p, 'E', fnID).code).join('+');\n                    return {code: `'['+${paramsCode}+']'`, type: 'E'};\n                } else {\n                    throw new Error(\n                        `Compile function ${getOperationName()} not supported, call compileParams or compileReturn instead.`\n                    );\n                }\n            case ReflectionKind.parameter: {\n                const rt = runType as ParameterRunType;\n                switch (src.subKind) {\n                    case ReflectionSubKind.mapKey:\n                    case ReflectionSubKind.mapValue:\n                    case ReflectionSubKind.setItem:\n                        return compileStringifyGenericMember(rt, comp);\n                    default:\n                        return compileStringifyParameter(rt, comp);\n                }\n            }\n            case ReflectionKind.property:\n            case ReflectionKind.propertySignature: {\n                const rt = runType as PropertyRunType;\n                const child = rt.getJitChild(comp);\n                const childJit = comp.compile(child, 'E', fnID);\n                if (!child || !childJit?.code) return {code: undefined, type: 'E'};\n                // this can´t be processed in the parent as we need to handle the empty string case when value is undefined\n                const sep = rt.skipCommas ? '' : '+\",\"';\n                // encoding safe property with ':' inside the string saves a little processing\n                // when prop is not safe we need to double encode double quotes and escape characters\n                const propDef = getPropName(rt, comp);\n                if (rt.src.optional) {\n                    rt.tempChildVλl = comp.getChildVλl();\n                    // TODO: check if json for an object with first property undefined is valid (maybe the comma must be dynamic too)\n                    return {code: `(${rt.tempChildVλl} === undefined ? '' : ${propDef}+${childJit.code}${sep})`, type: 'E'};\n                }\n                return {code: `${propDef}+${childJit.code}${sep}`, type: 'E'};\n            }\n            case ReflectionKind.rest: {\n                const rt = runType as RestParamsRunType;\n                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);\n                const itemCodeStr = childJit?.code || 'JSON.stringify(' + comp.getChildVλl() + ')';\n                const arrName = comp.getLocalVarName('res', rt);\n                const itemName = comp.getLocalVarName('its', rt);\n                const index = rt.getChildVarName(comp);\n                const isFist = rt.getChildIndex(comp) === 0;\n                const sep = isFist ? '' : `','+`;\n                return {\n                    code: `\n                const ${arrName} = [];\n                for (let ${index} = ${rt.getChildIndex(comp)}; ${index} < ${comp.vλl}.length; ${index}++) {\n                    const ${itemName} = ${itemCodeStr};\n                    if(${itemName}) ${arrName}.push(${itemName});\n                }\n                if (!${arrName}.length) {return '';}\n                else {return ${sep}${arrName}.join(',')}\n            `,\n                    type: 'RB',\n                };\n            }\n            case ReflectionKind.tupleMember: {\n                const rt = runType as ParameterRunType;\n                const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);\n                const childCodeStr = childJit?.code || `null`; // non serializable types are set to null\n                if (rt.isRest()) return childJit || {code: `null`, type: 'E'};\n                const isFirst = rt.getChildIndex(comp) === 0;\n                const sep = isFirst ? '' : `','+`;\n                if (rt.isOptional())\n                    return {code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: 'E'};\n                return {code: `${sep}${childCodeStr}`, type: 'E'};\n            }\n            case ReflectionKind.promise: {\n                throw new Error(`Jit compilation disabled for Non Serializable types.`);\n            }\n\n            // ###################### COLLECTION RUNTYPES ######################\n            // Types that contain other types as members\n            case ReflectionKind.objectLiteral:\n            case ReflectionKind.intersection: {\n                if (runType.src.subKind === ReflectionSubKind.nonSerializable) {\n                    throw new Error(`${getOperationName()} is disabled for Non Serializable types.`);\n                } else {\n                    const rt = runType as InterfaceRunType;\n                    return compileStringifyInterface(rt, comp);\n                }\n            }\n            case ReflectionKind.class:\n                return compileStringifyClass(runType, comp);\n            case ReflectionKind.infer:\n                throw new Error('Infer is not supported.');\n            case ReflectionKind.tuple: {\n                const rt = runType as TupleRunType;\n                const skip = rt.skipJit(comp);\n                if (skip) return {code: '', type: 'E'};\n                if (rt.getChildRunTypes().length === 0) return {code: `'[]'`, type: 'E'};\n                const paramsCode = rt\n                    .getChildRunTypes()\n                    .map((p) => comp.compile(p, 'E', fnID).code)\n                    .join('+');\n                return {code: `'['+${paramsCode}+']'`, type: 'E'};\n            }\n            case ReflectionKind.typeParameter:\n                // Type parameter has been replaced by tuple member internally so this should never be called\n                throw new Error('Type parameter not implemented.');\n            case ReflectionKind.union: {\n                const urt = runType as UnionRunType;\n                urt.checkAllowedChildren(comp);\n                const {simpleItems, objectTypes, anyItem} = urt.getUnionChildren(comp);\n                const errName = comp.getLocalVarName('uErr', urt);\n                const fail = `throw new Error(${errName});`;\n                comp.setContextItem(\n                    errName,\n                    `const ${errName} = \"Can not ${getOperationName()} union: item does not belong to the union\"`\n                );\n                const ifElse = createIfElseFn();\n                // Helper to generate stringify code for a union item\n                const getStringifyCode = (unionItem: BaseRunType) => {\n                    const childJit = comp.compile(unionItem, 'E', fnID);\n                    const encJit = comp.compilePrepareForJson(unionItem, 'E');\n                    const decJit = comp.compileRestoreFromJson(unionItem, 'E');\n                    const needsTupleEncoding = !!encJit?.code || !!decJit?.code;\n                    const skiEncode = !childJit?.code || childJit.code === comp.vλl;\n                    const stringifyCode = skiEncode ? comp.vλl : childJit.code;\n                    const index = urt.getUnionItemIndex(comp, unionItem);\n                    const toTuple = `'[${index},' + ${stringifyCode} + ']'`;\n                    const tupleCode = unionItem.getFamily() === 'A' ? `(${toTuple})` : toTuple;\n                    return needsTupleEncoding ? `return ${tupleCode}` : `return ${stringifyCode}`;\n                };\n                // Generate code for simple items (atomic types)\n                const simpleCode = simpleItems.map((unionItem) => {\n                    const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);\n                    return `${ifElse()} (${isTypeCode}) {${getStringifyCode(unionItem)}}`;\n                });\n                // Generate code for object types (need null guard)\n                const objCode = objectTypes.length\n                    ? objectTypes.map((unionItem) => {\n                          const isTypeCode = urt.getChildIsTypeWithLooseCheck(unionItem, comp);\n                          return `${ifElse()} (typeof ${comp.vλl} === 'object' && ${comp.vλl} !== null && ${isTypeCode}) {${getStringifyCode(unionItem)}}`;\n                      })\n                    : [];\n                // Generate code for anyItem (always matches, checked last as fallback)\n                const anyCode = anyItem ? `${ifElse(true)} {${getStringifyCode(anyItem)}}` : `${ifElse(true)} {${fail}}`;\n\n                return {code: [...simpleCode, ...objCode, anyCode].join(''), type: 'RB'};\n            }\n            default:\n                throw new Error(`Cant ${getOperationName()} for unsupported RunType: ${runType.getTypeName()}`);\n        }\n    }\n\n    function getOperationName() {\n        switch (fnID) {\n            case JitFunctions.stringifyJson.id:\n                return 'StringifyJson';\n            case JitFunctions.toJSCode.id:\n                return 'ToCode';\n            default:\n                throw new Error(`Unknown operation: ${fnID}`);\n        }\n    }\n\n    function getPropName(rt: PropertyRunType, comp: JitFnCompiler): string {\n        if (!isSafePropName(rt.src.name)) return `${JSON.stringify(rt.getChildLiteral(comp) as string)}+':'`;\n        if (fnID === JitFunctions.toJSCode.id) return `'${rt.getChildVarName(comp)}:'`;\n        return `'\"${rt.getChildVarName(comp)}\":'`;\n    }\n\n    function compileStringifyParameter(rt: ParameterRunType, comp: JitFnCompiler): JitCode {\n        const childJit = comp.compile(rt.getJitChild(comp), 'E', fnID);\n        const childCodeStr = childJit?.code || `null`; // non serializable types are set to null\n        if (rt.isRest()) return childJit || {code: `null`, type: 'E'};\n        const isFirst = rt.getChildIndex(comp) === 0;\n        const sep = isFirst ? '' : `','+`;\n        if (rt.isOptional())\n            return {code: `(${comp.getChildVλl()} === undefined ? ${sep}'null' : ${sep}${childCodeStr})`, type: 'E'};\n        return {code: `${sep}${childCodeStr}`, type: 'E'};\n    }\n\n    function compileStringifyGenericMember(rt: ParameterRunType, comp: JitFnCompiler): JitCode {\n        const child = rt.getJitChild(comp);\n        const argCode = comp.compile(child, 'E', fnID);\n        if (!argCode?.code) return {code: undefined, type: 'E'};\n        const isFirst = rt.getChildIndex(comp) === 0;\n        const sep = isFirst ? '' : `','+`;\n        if (rt.isOptional()) return {code: `(${comp.getChildVλl()} === undefined ? '': ${sep}${argCode.code})`, type: 'E'};\n        return {code: `${sep}${argCode.code}`, type: 'E'};\n    }\n\n    function compileStringifyInterface(rt: InterfaceRunType, comp: JitFnCompiler): JitCode {\n        if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'E', fnID);\n        const children = rt.getJsonStringifySortedChildren(comp);\n        if (children.length === 0) return {code: `''`, type: 'E'};\n        const allOptional = children.every((prop) => (prop as MemberRunType<any>).isOptional());\n        // if all properties are optional,  we can not optimize and use JSON.stringify\n        if (allOptional) return compileInterfaceIntoArray(rt, comp, children);\n        const childrenCode = children\n            .map((prop, i) => {\n                const nexChild = children[i + 1];\n                const isLast = !nexChild;\n                prop.skipCommas = isLast;\n                return comp.compile(prop, 'E', fnID).code;\n            })\n            .filter(Boolean)\n            .join('+');\n        return {code: `'{'+${childrenCode}+'}'`, type: 'E'};\n    }\n\n    function compileInterfaceIntoArray(rt: InterfaceRunType, comp: JitFnCompiler, children: MemberRunType<any>[]): JitCode {\n        const arrName = comp.getLocalVarName('ns', rt);\n        const childrenCode = children\n            .map((prop) => {\n                prop.skipCommas = true;\n                const childJit = comp.compile(prop, 'E', fnID);\n                if (!childJit?.code) return '';\n                const code = `${arrName}.push(${childJit.code})`;\n                // makes an extra check to avoid pushing empty strings to the array (childJit also makes the same check but is better than having to filter the array after)\n                return prop.isOptional() && prop.tempChildVλl ? `if (${prop.tempChildVλl} !== undefined){${code}}` : `${code};`;\n            })\n            .filter(Boolean)\n            .join('');\n\n        return {code: `(function(){const ${arrName} = [];${childrenCode};return '{'+${arrName}.join(',')+'}'})()`, type: 'E'};\n    }\n\n    function compileStringifyClass(runType: BaseRunType, comp: JitFnCompiler): JitCode {\n        switch (runType.src.subKind) {\n            case ReflectionSubKind.date:\n                return {code: `'\"'+${comp.vλl}.toJSON()+'\"'`, type: 'E'};\n            case ReflectionSubKind.map: {\n                const rt = runType as unknown as MapRunType;\n                return compileStringifyIterable(rt as unknown as IterableRunType, comp);\n            }\n            case ReflectionSubKind.set: {\n                const rt = runType as unknown as SetRunType;\n                return compileStringifyIterable(rt as unknown as IterableRunType, comp);\n            }\n            case ReflectionSubKind.nonSerializable:\n                throw new Error(`Jit compilation disabled for Non Serializable types.`);\n            default: {\n                const rt = runType as unknown as ClassRunType;\n                if (rt.isCallable()) {\n                    const callSignature = rt.getCallSignature();\n                    if (callSignature) return comp.compile(callSignature, 'E', fnID);\n                }\n                // optional and index properties must be compiled first to prevent trailing commas\n                // this is because the last trailing comma is calculated statically\n                // maybe we need to move that trailing comma compilation to be dynamic\n                // but we would need to create a self invoking function for that\n                const children = rt.getJsonStringifySortedChildren(comp);\n                if (children.length === 0) return {code: `''`, type: 'E'};\n                const childrenCode = children\n                    .map((prop, i) => {\n                        const nexChild = children[i + 1];\n                        const isLast = !nexChild;\n                        prop.skipCommas = isLast;\n                        return comp.compile(prop, 'E', fnID).code;\n                    })\n                    .filter(Boolean)\n                    .join('+');\n                return {code: `'{'+${childrenCode}+'}'`, type: 'E'};\n            }\n        }\n    }\n\n    return compileStringify;\n}\n\nexport function createStringifyIterable(fnID: Operation) {\n    return function compileStringifyIterable(\n        rt: IterableRunType,\n        comp: JitFnCompiler,\n        /** prefix characters to add before the generated array, used when generating code instead json */\n        codePrefix: string = '',\n        /** suffix characters to add after the generated array, used when generating code instead json */\n        codeSuffix: string = ''\n    ): JitCode {\n        const entry = rt.getCustomVλl(comp)?.vλl || comp.vλl;\n        const jitChildren = rt.getJitChildren(comp);\n        const childrenCode = jitChildren.map((c) => comp.compile(c, 'E', fnID).code).join('+');\n        const jsonItems = comp.getLocalVarName('ls', rt);\n        const resultVal = comp.getLocalVarName('res', rt);\n        const childrenResult = jitChildren.length > 1 ? `'['+${childrenCode}+']'` : childrenCode;\n        const earlyReturn = codePrefix && codeSuffix ? `if (!${jsonItems}.length) return '${codePrefix}${codeSuffix}';` : '';\n        return {\n            code: `\n        const ${jsonItems} = [];\n        for (const ${entry} of ${comp.vλl}) {\n            const ${resultVal} = ${childrenResult};\n            ${jsonItems}.push(${resultVal});\n        }\n        ${earlyReturn}return '${codePrefix}[' + ${jsonItems}.join(',') + ']${codeSuffix}'\n    `,\n            type: 'RB',\n        };\n    };\n}\n\nexport const emitJsonStringify = createStringifyCompiler(JitFunctions.stringifyJson.id);\n"],"names":["ReflectionKind","parentIs","cpf_asJSONString","ReflectionSubKind","createIfElseFn","JitFunctions","isSafePropName"],"mappings":"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"}

package/.dist/cjs/src/jitCompilers/json/stringifyJson.d.ts

@@ -0,0 +1,10 @@
+import { JitFunctions } from '../../constants.functions.ts';
+import { JitFnCompiler } from '../../lib/jitFnCompiler.ts';
+import { JitCode } from '../../types.ts';
+import { BaseRunType } from '../../lib/baseRunTypes.ts';
+import { IterableRunType } from '../../nodes/native/Iterable.ts';
+type Operation = typeof JitFunctions.stringifyJson.id | typeof JitFunctions.toJSCode.id;
+export declare function createStringifyCompiler(fnID: Operation): (runType: BaseRunType, comp: JitFnCompiler) => JitCode;
+export declare function createStringifyIterable(fnID: Operation): (rt: IterableRunType, comp: JitFnCompiler, codePrefix?: string, codeSuffix?: string) => JitCode;
+export declare const emitJsonStringify: (runType: BaseRunType, comp: JitFnCompiler) => JitCode;
+export {};

package/.dist/cjs/src/jitCompilers/json/stringifySpec/stringifyHelpers.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_constants_functions = require("../../../constants.functions.cjs");
+const SERIALIZE_FN = src_constants_functions.JitFunctions.stringifyJson;
+const DESERIALIZE_FN = src_constants_functions.JitFunctions.restoreFromJson;
+function createSerializationFns(rt) {
+  const serialize = rt.createJitFunction(SERIALIZE_FN);
+  const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationParamsFn(rt, sliceStart) {
+  const params = typeof sliceStart === "number" ? { paramsSlice: { start: sliceStart } } : void 0;
+  const serialize = rt.createJitParamsFunction(SERIALIZE_FN, params);
+  const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationReturnFn(rt) {
+  const serialize = rt.createJitReturnFunction(SERIALIZE_FN);
+  const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureParamsFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const serialize = callSignature.createJitParamsFunction(SERIALIZE_FN);
+  const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function createSerializationCallSignatureReturnFn(rt) {
+  const callSignature = rt.getCallSignature();
+  const serialize = callSignature.createJitReturnFunction(SERIALIZE_FN);
+  const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);
+  const deserialize = (data) => restoreFromJson(JSON.parse(data));
+  return { serialize, deserialize };
+}
+function roundTrip(serialize, deserialize, value) {
+  const serialized = serialize(value);
+  const deserialized = deserialize(serialized);
+  const result = { serialized, deserialized };
+  return result;
+}
+exports.createSerializationCallSignatureParamsFn = createSerializationCallSignatureParamsFn;
+exports.createSerializationCallSignatureReturnFn = createSerializationCallSignatureReturnFn;
+exports.createSerializationFns = createSerializationFns;
+exports.createSerializationParamsFn = createSerializationParamsFn;
+exports.createSerializationReturnFn = createSerializationReturnFn;
+exports.roundTrip = roundTrip;
+//# sourceMappingURL=stringifyHelpers.cjs.map

package/.dist/cjs/src/jitCompilers/json/stringifySpec/stringifyHelpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringifyHelpers.cjs","sources":["../../../../../../src/jitCompilers/json/stringifySpec/stringifyHelpers.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 type {InterfaceRunType} from '../../../nodes/collection/interface.ts';\nimport type {FunctionRunType} from '../../../nodes/function/function.ts';\nimport type {RunType} from '../../../types.ts';\n\nconst SERIALIZE_FN = JitFunctions.stringifyJson;\nconst DESERIALIZE_FN = JitFunctions.restoreFromJson;\n\nexport function createSerializationFns(rt: RunType) {\n    const serialize = rt.createJitFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitFunction(DESERIALIZE_FN);\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\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 serialize = rt.createJitParamsFunction(SERIALIZE_FN, params);\n    const restoreFromJson = rt.createJitParamsFunction(DESERIALIZE_FN, params);\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationReturnFn(rt: FunctionRunType) {\n    const serialize = rt.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = rt.createJitReturnFunction(DESERIALIZE_FN);\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureParamsFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const serialize = callSignature.createJitParamsFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitParamsFunction(DESERIALIZE_FN);\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function createSerializationCallSignatureReturnFn(rt: InterfaceRunType) {\n    const callSignature = rt.getCallSignature()!;\n    const serialize = callSignature.createJitReturnFunction(SERIALIZE_FN);\n    const restoreFromJson = callSignature.createJitReturnFunction(DESERIALIZE_FN);\n    const deserialize = (data: any) => restoreFromJson(JSON.parse(data));\n    return {serialize, deserialize};\n}\n\nexport function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any) {\n    const serialized = serialize(value);\n    const deserialized = deserialize(serialized);\n    const result = {serialized, deserialized};\n    return result;\n}\n"],"names":["JitFunctions"],"mappings":";;;AAYA,MAAM,eAAeA,wBAAAA,aAAa;AAClC,MAAM,iBAAiBA,wBAAAA,aAAa;AAE7B,SAAS,uBAAuB,IAAa;AAChD,QAAM,YAAY,GAAG,kBAAkB,YAAY;AACnD,QAAM,kBAAkB,GAAG,kBAAkB,cAAc;AAC3D,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB,YAAqB;AAClF,QAAM,SAAS,OAAO,eAAe,WAAW,EAAC,aAAa,EAAC,OAAO,WAAA,EAAU,IAAK;AACrF,QAAM,YAAY,GAAG,wBAAwB,cAAc,MAAM;AACjE,QAAM,kBAAkB,GAAG,wBAAwB,gBAAgB,MAAM;AACzE,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,4BAA4B,IAAqB;AAC7D,QAAM,YAAY,GAAG,wBAAwB,YAAY;AACzD,QAAM,kBAAkB,GAAG,wBAAwB,cAAc;AACjE,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,YAAY,cAAc,wBAAwB,YAAY;AACpE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,yCAAyC,IAAsB;AAC3E,QAAM,gBAAgB,GAAG,iBAAA;AACzB,QAAM,YAAY,cAAc,wBAAwB,YAAY;AACpE,QAAM,kBAAkB,cAAc,wBAAwB,cAAc;AAC5E,QAAM,cAAc,CAAC,SAAc,gBAAgB,KAAK,MAAM,IAAI,CAAC;AACnE,SAAO,EAAC,WAAW,YAAA;AACvB;AAEO,SAAS,UAAU,WAA+B,aAAiC,OAAY;AAClG,QAAM,aAAa,UAAU,KAAK;AAClC,QAAM,eAAe,YAAY,UAAU;AAC3C,QAAM,SAAS,EAAC,YAAY,aAAA;AAC5B,SAAO;AACX;;;;;;;"}

package/.dist/cjs/src/jitCompilers/json/stringifySpec/stringifyHelpers.d.ts

@@ -0,0 +1,27 @@
+import { InterfaceRunType } from '../../../nodes/collection/interface.ts';
+import { FunctionRunType } from '../../../nodes/function/function.ts';
+import { RunType } from '../../../types.ts';
+export declare function createSerializationFns(rt: RunType): {
+    serialize: (...args: any[]) => any;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationParamsFn(rt: FunctionRunType, sliceStart?: number): {
+    serialize: (...args: any[]) => any;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationReturnFn(rt: FunctionRunType): {
+    serialize: (...args: any[]) => any;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationCallSignatureParamsFn(rt: InterfaceRunType): {
+    serialize: (...args: any[]) => any;
+    deserialize: (data: any) => any;
+};
+export declare function createSerializationCallSignatureReturnFn(rt: InterfaceRunType): {
+    serialize: (...args: any[]) => any;
+    deserialize: (data: any) => any;
+};
+export declare function roundTrip(serialize: (v: any) => string, deserialize: (v: string) => any, value: any): {
+    serialized: string;
+    deserialized: any;
+};