@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/jitCompilers/binary/fromBinary.cjs

@@ -0,0 +1,383 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const core = require("@mionjs/core");
+const src_constants_kind = require("../../constants.kind.cjs");
+const src_lib_utils = require("../../lib/utils.cjs");
+const src_constants_functions = require("../../constants.functions.cjs");
+const src_constants = require("../../constants.cjs");
+const fnID = src_constants_functions.JitFunctions.fromBinary.id;
+function emitFromBinary(runType, comp) {
+  const src = runType.src;
+  const kind = src.kind;
+  const dεs = comp.args.dεs;
+  switch (kind) {
+    // ###################### ATOMIC TYPES ######################
+    case type.ReflectionKind.unknown:
+    case type.ReflectionKind.any: {
+      return { code: `JSON.parse(${dεs}.desString())`, type: "E" };
+    }
+    case type.ReflectionKind.null:
+      return { code: `(${dεs}.index++, null)`, type: "E" };
+    case type.ReflectionKind.boolean:
+      return { code: `${dεs}.view.getUint8(${dεs}.index++) === 1`, type: "E" };
+    case type.ReflectionKind.number: {
+      return { code: `${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8))`, type: "E" };
+    }
+    case type.ReflectionKind.string: {
+      return { code: `${dεs}.desString()`, type: "E" };
+    }
+    case type.ReflectionKind.bigint: {
+      return { code: `BigInt(${dεs}.desString(true))`, type: "E" };
+    }
+    case type.ReflectionKind.undefined:
+    case type.ReflectionKind.void:
+      return { code: `(${dεs}.index++, undefined)`, type: "E" };
+    case type.ReflectionKind.symbol: {
+      return { code: `Symbol(${dεs}.desString() || undefined)`, type: "E" };
+    }
+    case type.ReflectionKind.regexp: {
+      return { code: `new RegExp(${dεs}.desString(), ${dεs}.desString())`, type: "E" };
+    }
+    case type.ReflectionKind.object:
+      return { code: `JSON.parse(${dεs}.desString())`, type: "E" };
+    case type.ReflectionKind.enum: {
+      return { code: `${dεs}.desEnum()`, type: "E" };
+    }
+    case type.ReflectionKind.enumMember:
+      throw new Error("Binary deserialization not supported for enum member types");
+    case type.ReflectionKind.never:
+      throw new Error("Never type cannot be deserialized from Binary");
+    case type.ReflectionKind.templateLiteral:
+      throw new Error("Template literals are not supported in Binary deserialization");
+    case type.ReflectionKind.literal: {
+      if (comp.opts.noLiterals) {
+        const lit = runType.src.literal;
+        if (lit instanceof RegExp) return emitFromBinaryAs(runType, comp, type.ReflectionKind.regexp);
+        switch (typeof lit) {
+          case "string":
+            return emitFromBinaryAs(runType, comp, type.ReflectionKind.string);
+          case "number":
+            return emitFromBinaryAs(runType, comp, type.ReflectionKind.number);
+          case "boolean":
+            return emitFromBinaryAs(runType, comp, type.ReflectionKind.boolean);
+          case "bigint":
+            return emitFromBinaryAs(runType, comp, type.ReflectionKind.bigint);
+          case "symbol":
+            return emitFromBinaryAs(runType, comp, type.ReflectionKind.symbol);
+          default:
+            throw new Error(`Unsupported literal type ${typeof lit}`);
+        }
+      }
+      return { code: src_lib_utils.toLiteral(runType.src.literal), type: "E" };
+    }
+    // ###################### MEMBER RUNTYPES ######################
+    // Types that represent members of collections or other structures
+    case type.ReflectionKind.rest:
+    // rest params are deserialized as array but start at rest item index
+    case type.ReflectionKind.array: {
+      const rt = runType;
+      rt.checkNonSkipTypes(comp);
+      const child = rt.getMemberType();
+      const childCode = comp.compile(child, "S", fnID);
+      if (!childCode?.code) throw new Error(`Do not know how to deserialize Array<${child.getTypeName()}> from Binary.`);
+      const isRest = rt.src.kind === type.ReflectionKind.rest;
+      const index = rt.getChildVarName(comp);
+      const isExpression = src_lib_utils.childIsExpression(childCode, child);
+      const code = isExpression ? `${comp.getChildVλl()} = ${childCode.code};` : childCode.code;
+      const lengthVal = comp.getLocalVarName("arrL", rt);
+      const arrayInit = isRest ? "" : `${comp.vλl} = new Array(${lengthVal})`;
+      return {
+        code: `
+                const ${lengthVal} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${arrayInit};
+                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${lengthVal}; ${index}++) {${code}}
+            `,
+        type: "S"
+      };
+    }
+    case type.ReflectionKind.indexSignature: {
+      const rt = runType;
+      const indexKind = rt.src.index?.kind;
+      const memberCode = comp.compile(rt.getJitChild(comp), "S", fnID);
+      if (!memberCode?.code) return { code: void 0, type: "E" };
+      const prop = rt.getChildVarName(comp);
+      const countVar = comp.getLocalVarName("cnt", rt);
+      const indexVar = comp.getLocalVarName("propI", rt);
+      let keyDeserializationCode;
+      if (indexKind === type.ReflectionKind.number) {
+        keyDeserializationCode = `const ${prop} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4;`;
+      } else {
+        keyDeserializationCode = `const ${prop} = ${dεs}.desSafePropName();`;
+      }
+      const memberInit = memberCode.type === "E" ? `${comp.vλl}[${prop}] = ${memberCode.code};` : memberCode.code;
+      const deserializeCode = `for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {${keyDeserializationCode}${memberInit}}`;
+      return {
+        code: `const ${countVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${comp.vλl} = {}; ${deserializeCode}`,
+        type: "S"
+      };
+    }
+    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) {
+        return emitFromBinaryAs(runType, comp, type.ReflectionKind.tuple);
+      } else {
+        throw new Error(
+          "Binary deserialization not supported for functions, 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: {
+          const child = rt.getJitChild(comp);
+          const childJit = comp.compile(child, "S", fnID);
+          if (!childJit?.code || !child)
+            throw new Error(`Do not know how to deserialize ${rt.getTypeName()} from Binary.`);
+          const parent = rt.getParent();
+          const parentVλl = parent.getCustomVλl(comp)?.vλl || comp.vλl;
+          const vλl = rt.getCustomVλl(comp)?.vλl;
+          const isExpression = src_lib_utils.childIsExpression(childJit, child);
+          const code = isExpression ? `const ${vλl} = ${childJit.code};` : childJit.code || "";
+          let setOperation = "";
+          switch (rt.src.subKind) {
+            case src_constants_kind.ReflectionSubKind.mapKey:
+              break;
+            // we set map item once we have the key and value
+            case src_constants_kind.ReflectionSubKind.mapValue: {
+              const mapKey = parent.getMapKeyVλl(comp);
+              setOperation = `${parentVλl}.set(${mapKey}, ${vλl})`;
+              break;
+            }
+            case src_constants_kind.ReflectionSubKind.setItem:
+              setOperation = `${parentVλl}.add(${vλl})`;
+              break;
+          }
+          return { code: `${code}; ${setOperation};`, type: "S" };
+        }
+        default:
+          return emitFromBinaryAs(runType, comp, type.ReflectionKind.tupleMember);
+      }
+    }
+    case type.ReflectionKind.property:
+    case type.ReflectionKind.propertySignature: {
+      const rt = runType;
+      const parent = rt.getParent();
+      const child = rt.getJitChild(comp);
+      const childJit = comp.compile(child, "S", fnID);
+      if (rt.isOptional()) {
+        const { bitMIndexVar, bitIndex } = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);
+        const initCode = childJit.type === "E" ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code;
+        return {
+          code: `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`,
+          type: "S"
+        };
+      }
+      const isExpression = src_lib_utils.childIsExpression(childJit, child);
+      if (!isExpression) {
+        return childJit;
+      }
+      const propName = getPropName(rt, comp);
+      return { code: `${propName}:${childJit?.code}`, type: "E" };
+    }
+    case type.ReflectionKind.tupleMember: {
+      const rt = runType;
+      const childJit = comp.compile(rt.getJitChild(comp), "S", fnID);
+      const nullJIt = emitFromBinaryAs(rt, comp, type.ReflectionKind.undefined);
+      const itemJit = childJit?.code ? childJit : nullJIt;
+      const initCode = itemJit.type === "E" ? `${comp.getChildVλl()} = ${itemJit.code}` : itemJit.code;
+      if (rt.isRest()) return itemJit;
+      const optionalIndex = rt.optionalIndex;
+      const bitMIndexVar = rt._bitmapVar;
+      const isFnParam = rt._isFnParam;
+      const isOptional = rt.isOptional() || isFnParam;
+      if (isOptional && optionalIndex !== void 0 && bitMIndexVar) {
+        const bitIndex = optionalIndex & 7;
+        const code = `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`;
+        return { code, type: "S" };
+      }
+      return { code: initCode, type: "S" };
+    }
+    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: {
+      const rt = runType;
+      if (rt.isCallable()) return comp.compile(rt.getCallSignature(), "S", fnID);
+      if (runType.src.subKind === src_constants_kind.ReflectionSubKind.nonSerializable) {
+        throw new Error("Binary deserialization is disabled for Non Serializable types");
+      } else {
+        const { required, optional, indexSignatures } = rt.splitJitSplitChildren(comp);
+        if (indexSignatures.length) {
+          return comp.compile(indexSignatures[0], "S", fnID);
+        }
+        const requiredItemsJit = required.map((prop) => comp.compile(prop, "S", fnID));
+        const expressionItemsJit = requiredItemsJit.filter((childJit, i) => src_lib_utils.childIsExpression(childJit, required[i])).map((prop) => prop.code).filter(Boolean);
+        const statementItemsCode = requiredItemsJit.filter(Boolean).filter((childJit, i) => !src_lib_utils.childIsExpression(childJit, required[i])).map((prop) => prop.code);
+        const expressionsPropsCode = expressionItemsJit.join(",");
+        const requiredPropsCode = statementItemsCode.join(";");
+        let optionalPropsCode = "";
+        if (optional.length) {
+          const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, false);
+          const propsCode = optional.map((prop, i) => {
+            prop.optionalIndex = i;
+            const modIndex = i + 1;
+            const shouldIncreaseBufferIndex = modIndex % 8 === 0;
+            const propCode = comp.compile(prop, "S", fnID).code;
+            if (!shouldIncreaseBufferIndex) return propCode;
+            return `${propCode} ${bitMIndexVar}++; `;
+          }).filter(Boolean).join("");
+          const sep = requiredPropsCode ? ";" : "";
+          optionalPropsCode = `${sep}
+${bitMapInit}
+${propsCode}`;
+        }
+        const canBeExpression = !requiredPropsCode && !optionalPropsCode;
+        if (canBeExpression) return { code: `{${expressionsPropsCode}}`, type: "E" };
+        return { code: `${comp.vλl} = {${expressionsPropsCode}}
+${requiredPropsCode}${optionalPropsCode}`, type: "S" };
+      }
+    }
+    case type.ReflectionKind.class:
+      switch (runType.src.subKind) {
+        case src_constants_kind.ReflectionSubKind.date:
+          return { code: `new Date(${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8)))`, type: "E" };
+        case src_constants_kind.ReflectionSubKind.map:
+        case src_constants_kind.ReflectionSubKind.set: {
+          const rt = runType;
+          const children = rt.getJitChildren(comp);
+          const vλl = rt.getCustomVλl(comp)?.vλl || comp.vλl;
+          const initCode = `const ${vλl} = new ${rt.constructorName}()`;
+          if (!children.length) return { code: `new ${rt.constructorName}()`, type: "E" };
+          const childrenCode = children.map((c) => comp.compile(c, "S", fnID).code).filter(Boolean).join(";");
+          if (!childrenCode) return { code: initCode, type: "E" };
+          const index = comp.getLocalVarName("itI", rt);
+          const lengthVar = comp.getLocalVarName("itL", rt);
+          const readLength = `const ${lengthVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4`;
+          return {
+            code: `${initCode}; ${readLength}; for (let ${index} = 0; ${index} < ${lengthVar}; ${index}++) {${childrenCode}} ${comp.vλl} = ${vλl};`,
+            type: "S"
+          };
+        }
+        case src_constants_kind.ReflectionSubKind.nonSerializable:
+          throw new Error("Binary deserialization disabled for Non Serializable types");
+        default: {
+          const rt = runType;
+          if (rt.isCallable()) {
+            const callSignature = rt.getCallSignature();
+            if (callSignature) return comp.compile(callSignature, "S", fnID);
+          }
+          const originalKind = rt.src.kind;
+          runType.src.kind = type.ReflectionKind.objectLiteral;
+          const plainObjCode = emitFromBinary(rt, comp);
+          runType.src.kind = originalKind;
+          const desFnVarName = comp.getLocalVarName("desFn", rt);
+          const desFnInit = `let ${desFnVarName} = utl.${core.getJitUtils().getDeserializeFn.name}(${src_lib_utils.toLiteral(rt.getClassName())})`;
+          const desFnCode = `if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}`;
+          const desClassCode = `else if (${desFnVarName} = utl.${core.getJitUtils().getSerializeClass.name}(${src_lib_utils.toLiteral(rt.getClassName())})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}`;
+          const initCode = plainObjCode.type === "E" ? `${comp.vλl} = ${plainObjCode.code}` : plainObjCode.code;
+          return { code: `${initCode};${desFnInit};${desFnCode} ${desClassCode}`, type: "S" };
+        }
+      }
+      break;
+    case type.ReflectionKind.infer:
+      throw new Error("Infer is not supported in Binary deserialization");
+    case type.ReflectionKind.tuple: {
+      const rt = runType;
+      const skip = rt.skipJit(comp);
+      if (skip) return { code: void 0, type: "S" };
+      const params = rt.getParamRunTypes(comp);
+      const isFnParams = runType.src.subKind === src_constants_kind.ReflectionSubKind.params;
+      const hasFixedSize = !isFnParams && params.every((p) => !p.isOptional() && !p.isRest());
+      const initTuple = hasFixedSize ? `${comp.vλl} = new Array(${params.length});` : `${comp.vλl} = [];`;
+      if (params.length === 0) return { code: initTuple, type: "S" };
+      const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());
+      const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());
+      const rest = params.filter((p) => p.isRest());
+      const requiredCode = required.map((p) => comp.compile(p, "S", fnID).code || "").join(";");
+      let optionalCode = "";
+      if (optional.length) {
+        const { bitMapInit, bitMIndexVar } = getOptionalBitmapItems(rt, comp, optional.length, 0, true);
+        const optionalParamsCode = optional.map((p, i) => {
+          p.optionalIndex = i;
+          p._bitmapVar = bitMIndexVar;
+          p._isFnParam = isFnParams;
+          const paramCode = comp.compile(p, "S", fnID).code || "";
+          const modIndex = i + 1;
+          const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;
+          const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : "";
+          return `${paramCode} ${increaseIndex}`;
+        }).join("");
+        optionalCode = `${bitMapInit}
+${optionalParamsCode}`;
+      }
+      const restCode = rest.map((p) => comp.compile(p, "S", fnID).code || "").join(";");
+      const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(";");
+      return { code: `${initTuple}${allCode}`, type: "S" };
+    }
+    case type.ReflectionKind.typeParameter:
+      throw new Error("Type parameter not implemented in Binary deserialization");
+    case type.ReflectionKind.union: {
+      const rt = runType;
+      rt.checkAllowedChildren(comp);
+      const decVar = comp.getLocalVarName("dec", rt);
+      const errVarName = comp.getLocalVarName("uErr", rt);
+      comp.setContextItem(errVarName, `const ${errVarName} = "Can not binary decode union: invalid union index"`);
+      const children = rt.getJitChildren(comp);
+      if (children.length > src_constants.MAX_UNION_ITEMS) {
+        throw new Error(
+          `Binary deserialization not supported for Union with more than ${src_constants.MAX_UNION_ITEMS} items. Found ${children.length} in ${rt.getUnionTypeNames()}`
+        );
+      }
+      const maxIndex = children.length - 1;
+      const isUint16 = maxIndex > 255;
+      const readIndex = isUint16 ? `const ${decVar} = ${dεs}.view.getUint16(${dεs}.index, 1); ${dεs}.index += 2;` : `const ${decVar} = ${dεs}.view.getUint8(${dεs}.index++);`;
+      const ifElse = src_lib_utils.createIfElseFn();
+      const itemsCode = children.map((unionItem) => {
+        const childJit = comp.compile(unionItem, "S", fnID);
+        const isExpression = src_lib_utils.childIsExpression(childJit, unionItem);
+        const code2 = isExpression && childJit.code && childJit.code !== comp.vλl ? `${comp.vλl} = ${childJit.code}` : childJit.code || "";
+        const index = rt.getUnionItemIndex(comp, unionItem);
+        return `${ifElse()} (${decVar} === ${index}) {${code2 || "/*noop*/"}}`;
+      }).filter(Boolean);
+      const childrenCode = itemsCode.join("");
+      const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : "";
+      const code = `
+                ${readIndex}
+                ${childrenCode}
+                ${failCode}
+            `;
+      return { code, type: "S" };
+    }
+    default:
+      throw new Error(`Binary deserialization not supported for ${type.ReflectionKind[kind]} types`);
+  }
+  throw new Error(`Do not know how to deserialize ${runType.getTypeName()} from Binary.`);
+}
+function getPropName(rt, comp, isObjectConstructor) {
+  const isSafe = src_lib_utils.isSafePropName(rt.src.name);
+  return isSafe ? rt.getChildVarName(comp) : rt.getChildLiteral(comp);
+}
+function getOptionalBitmapItems(rt, comp, optionalLength = 0, currentIndex = 0, isTuple = false) {
+  const dεs = comp.args.dεs;
+  const prefix = isTuple ? "t" : "";
+  const bitMIndexVar = comp.getLocalVarName(`${prefix}bimI`, rt);
+  const bitmapLength = Math.ceil(optionalLength / 8);
+  const bitIndex = `${currentIndex} & 7`;
+  const bitMapInit = `${bitmapLength > 1 ? "let " : "const"} ${bitMIndexVar} = ${dεs}.index; ${dεs}.index += ${bitmapLength};`;
+  return { bitMIndexVar, bitmapLength, bitIndex, bitMapInit };
+}
+function emitFromBinaryAs(rt, comp, kind) {
+  const originalKind = rt.src.kind;
+  rt.src.kind = kind;
+  const result = emitFromBinary(rt, comp);
+  rt.src.kind = originalKind;
+  return result;
+}
+exports.emitFromBinary = emitFromBinary;
+//# sourceMappingURL=fromBinary.cjs.map

package/.dist/cjs/src/jitCompilers/binary/fromBinary.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromBinary.cjs","sources":["../../../../../src/jitCompilers/binary/fromBinary.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 {getJitUtils} from '@mionjs/core';\nimport {ReflectionSubKind} from '../../constants.kind.ts';\nimport {childIsExpression, createIfElseFn, isSafePropName, toLiteral} from '../../lib/utils.ts';\nimport {jitBinaryDeserializerArgs, JitFunctions} from '../../constants.functions.ts';\nimport {MAX_UNION_ITEMS} from '../../constants.ts';\nimport type {JitCode} from '../../types.ts';\nimport type {BaseRunType} from '../../lib/baseRunTypes.ts';\nimport {type BaseFnCompiler} from '../../lib/jitFnCompiler.ts';\nimport type {LiteralRunType} from '../../nodes/atomic/literal.ts';\nimport type {ArrayRunType} from '../../nodes/member/array.ts';\nimport type {PropertyRunType} from '../../nodes/member/property.ts';\nimport type {InterfaceRunType} from '../../nodes/collection/interface.ts';\nimport type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';\nimport type {ClassRunType} from '../../nodes/collection/class.ts';\nimport type {TupleRunType} from '../../nodes/collection/tuple.ts';\nimport type {ParameterRunType} from '../../nodes/member/param.ts';\nimport type {RestParamsRunType} from '../../nodes/member/restParams.ts';\nimport type {UnionRunType} from '../../nodes/collection/union.ts';\nimport type {IterableRunType} from '../../nodes/native/Iterable.ts';\nimport type {MapRunType} from '../../nodes/native/map.ts';\n\ntype BinaryCompiler = BaseFnCompiler<typeof jitBinaryDeserializerArgs, typeof JitFunctions.fromBinary.id>;\n\nconst fnID = JitFunctions.fromBinary.id;\n\n/**\n * Main Binary deserialization compiler function\n * Generates JIT code to deserialize Binary data to JavaScript values\n */\nexport function emitFromBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode {\n    const src = runType.src;\n    const kind = src.kind;\n    const dεs = comp.args.dεs;\n\n    // hack is used in some case to increase the index passing an extra argument to view.get methods\n    // ie: view.getUint32(index, littleEndian, index += 4);\n    // getUint32 only accepts 2 arguments, but we use the 3rd one to increase the index on a single statement so code can be used as an expression\n\n    switch (kind) {\n        // ###################### ATOMIC TYPES ######################\n        case ReflectionKind.unknown:\n        case ReflectionKind.any: {\n            // any is deserialized from json string\n            return {code: `JSON.parse(${dεs}.desString())`, type: 'E'};\n        }\n        case ReflectionKind.null:\n            return {code: `(${dεs}.index++, null)`, type: 'E'};\n        case ReflectionKind.boolean:\n            return {code: `${dεs}.view.getUint8(${dεs}.index++) === 1`, type: 'E'};\n        case ReflectionKind.number: {\n            return {code: `${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8))`, type: 'E'};\n        }\n        case ReflectionKind.string: {\n            return {code: `${dεs}.desString()`, type: 'E'};\n        }\n        case ReflectionKind.bigint: {\n            return {code: `BigInt(${dεs}.desString(true))`, type: 'E'};\n        }\n        case ReflectionKind.undefined:\n        case ReflectionKind.void:\n            return {code: `(${dεs}.index++, undefined)`, type: 'E'};\n        case ReflectionKind.symbol: {\n            return {code: `Symbol(${dεs}.desString() || undefined)`, type: 'E'};\n        }\n        case ReflectionKind.regexp: {\n            return {code: `new RegExp(${dεs}.desString(), ${dεs}.desString())`, type: 'E'};\n        }\n        case ReflectionKind.object:\n            // similar to any, this is deserialized as json string\n            return {code: `JSON.parse(${dεs}.desString())`, type: 'E'};\n        case ReflectionKind.enum: {\n            return {code: `${dεs}.desEnum()`, type: 'E'};\n        }\n        case ReflectionKind.enumMember:\n            throw new Error('Binary deserialization not supported for enum member types');\n        case ReflectionKind.never:\n            throw new Error('Never type cannot be deserialized from Binary');\n        case ReflectionKind.templateLiteral:\n            throw new Error('Template literals are not supported in Binary deserialization');\n        case ReflectionKind.literal: {\n            if (comp.opts.noLiterals) {\n                const lit = (runType as LiteralRunType).src.literal;\n                if (lit instanceof RegExp) return emitFromBinaryAs(runType, comp, ReflectionKind.regexp);\n                switch (typeof lit) {\n                    case 'string':\n                        return emitFromBinaryAs(runType, comp, ReflectionKind.string);\n                    case 'number':\n                        return emitFromBinaryAs(runType, comp, ReflectionKind.number);\n                    case 'boolean':\n                        return emitFromBinaryAs(runType, comp, ReflectionKind.boolean);\n                    case 'bigint':\n                        return emitFromBinaryAs(runType, comp, ReflectionKind.bigint);\n                    case 'symbol':\n                        return emitFromBinaryAs(runType, comp, ReflectionKind.symbol);\n                    default:\n                        throw new Error(`Unsupported literal type ${typeof lit}`);\n                }\n            }\n            return {code: toLiteral((runType as LiteralRunType).src.literal), type: 'E'};\n        }\n\n        // ###################### MEMBER RUNTYPES ######################\n        // Types that represent members of collections or other structures\n        case ReflectionKind.rest: // rest params are deserialized as array but start at rest item index\n        case ReflectionKind.array: {\n            const rt = runType as ArrayRunType | RestParamsRunType;\n            rt.checkNonSkipTypes(comp);\n            const child = rt.getMemberType()!;\n            const childCode = comp.compile(child, 'S', fnID);\n            if (!childCode?.code) throw new Error(`Do not know how to deserialize Array<${child.getTypeName()}> from Binary.`);\n            const isRest = rt.src.kind === ReflectionKind.rest;\n            const index = rt.getChildVarName(comp);\n            const isExpression = childIsExpression(childCode, child);\n            const code = isExpression ? `${comp.getChildVλl()} = ${childCode.code};` : childCode.code;\n            // deserialized from [length, items...]\n            const lengthVal = comp.getLocalVarName('arrL', rt);\n            const arrayInit = isRest ? '' : `${comp.vλl} = new Array(${lengthVal})`; // res array already initialized in parent\n            return {\n                code: `\n                const ${lengthVal} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${arrayInit};\n                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${lengthVal}; ${index}++) {${code}}\n            `,\n                type: 'S',\n            };\n        }\n\n        case ReflectionKind.indexSignature: {\n            const rt = runType as IndexSignatureRunType;\n            const indexKind = (rt.src as any).index?.kind;\n            const memberCode = comp.compile(rt.getJitChild(comp), 'S', fnID);\n            if (!memberCode?.code) return {code: undefined, type: 'E'};\n\n            const prop = rt.getChildVarName(comp);\n            const countVar = comp.getLocalVarName('cnt', rt);\n            const indexVar = comp.getLocalVarName('propI', rt);\n\n            // Deserialize key based on index type\n            let keyDeserializationCode: string;\n            if (indexKind === ReflectionKind.number) {\n                // For number indices, deserialize as uint32\n                keyDeserializationCode = `const ${prop} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4;`;\n            } else {\n                // For string indices, deserialize as string with prototype pollution protection\n                keyDeserializationCode = `const ${prop} = ${dεs}.desSafePropName();`;\n            }\n\n            const memberInit = memberCode.type === 'E' ? `${comp.vλl}[${prop}] = ${memberCode.code};` : memberCode.code;\n            const deserializeCode = `for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {${keyDeserializationCode}${memberInit}}`;\n\n            return {\n                code: `const ${countVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${comp.vλl} = {}; ${deserializeCode}`,\n                type: 'S',\n            };\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                return emitFromBinaryAs(runType, comp, ReflectionKind.tuple);\n            } else {\n                throw new Error(\n                    'Binary deserialization not supported for functions, call compileParams or compileReturn instead.'\n                );\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                    const child = rt.getJitChild(comp);\n                    const childJit = comp.compile(child, 'S', fnID);\n                    if (!childJit?.code || !child)\n                        throw new Error(`Do not know how to deserialize ${rt.getTypeName()} from Binary.`);\n                    const parent = rt.getParent()!;\n                    const parentVλl = parent.getCustomVλl(comp)?.vλl || comp.vλl;\n                    const vλl = rt.getCustomVλl(comp)?.vλl;\n                    const isExpression = childIsExpression(childJit, child);\n                    const code = isExpression ? `const ${vλl} = ${childJit.code};` : childJit.code || '';\n                    let setOperation = '';\n                    switch (rt.src.subKind) {\n                        case ReflectionSubKind.mapKey:\n                            break; // we set map item once we have the key and value\n                        case ReflectionSubKind.mapValue: {\n                            const mapKey = (parent as MapRunType).getMapKeyVλl(comp); // not the best solution but works\n                            setOperation = `${parentVλl}.set(${mapKey}, ${vλl})`;\n                            break;\n                        }\n                        case ReflectionSubKind.setItem:\n                            setOperation = `${parentVλl}.add(${vλl})`;\n                            break;\n                    }\n                    return {code: `${code}; ${setOperation};`, type: 'S'};\n                }\n                default:\n                    return emitFromBinaryAs(runType, comp, ReflectionKind.tupleMember);\n            }\n        }\n\n        case ReflectionKind.property:\n        case ReflectionKind.propertySignature: {\n            const rt = runType as PropertyRunType;\n            const parent = rt.getParent() as InterfaceRunType;\n            const child = rt.getJitChild(comp)!;\n            const childJit = comp.compile(child, 'S', fnID);\n            if (rt.isOptional()) {\n                const {bitMIndexVar, bitIndex} = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);\n                const initCode = childJit.type === 'E' ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code;\n                return {\n                    code: `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`,\n                    type: 'S',\n                };\n            }\n            // block or statements code are initialized as obj.a = deserializeA; obj.b = deserializeB; after initial object has been created\n            const isExpression = childIsExpression(childJit, child);\n            if (!isExpression) {\n                return childJit; // block statements already include variable assignment\n            }\n            // required props that are simple expressions code are part of an object constructor {a: deserializeA, b: deserializeB, c: deserializeC}\n            const propName = getPropName(rt, comp, true);\n            return {code: `${propName}:${childJit?.code}`, type: 'E'};\n        }\n\n        case ReflectionKind.tupleMember: {\n            const rt = runType as ParameterRunType;\n            const childJit = comp.compile(rt.getJitChild(comp), 'S', fnID);\n            const nullJIt = emitFromBinaryAs(rt, comp, ReflectionKind.undefined);\n            const itemJit = childJit?.code ? childJit : nullJIt; // if child is not serializable, we serialize null as need to fill the space in the tuple\n            const initCode = itemJit.type === 'E' ? `${comp.getChildVλl()} = ${itemJit.code}` : itemJit.code;\n            if (rt.isRest()) return itemJit;\n            // Optional handling uses bitmap set at tuple level\n            const optionalIndex = (rt as any).optionalIndex;\n            const bitMIndexVar = (rt as any)._bitmapVar;\n            const isFnParam = (rt as any)._isFnParam;\n            // Treat as optional if either isOptional() is true OR it's a function param (all fn params are optional in binary)\n            const isOptional = rt.isOptional() || isFnParam;\n            if (isOptional && optionalIndex !== undefined && bitMIndexVar) {\n                const bitIndex = optionalIndex & 7; // equivalent to optionalIndex % 8\n                const code = `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`;\n                return {code, type: 'S'};\n            }\n            return {code: initCode, type: 'S'};\n        }\n        case ReflectionKind.promise:\n            throw new Error('Jit compilation disabled for Non Serializable types.');\n\n        // ###################### COLLECTION RUNTYPES ######################\n        // Types that contain other types as members\n        case ReflectionKind.objectLiteral:\n        case ReflectionKind.intersection: {\n            const rt = runType as InterfaceRunType;\n            if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'S', fnID);\n            if (runType.src.subKind === ReflectionSubKind.nonSerializable) {\n                throw new Error('Binary deserialization is disabled for Non Serializable types');\n            } else {\n                const {required, optional, indexSignatures} = rt.splitJitSplitChildren(comp);\n                if (indexSignatures.length) {\n                    return comp.compile(indexSignatures[0], 'S', fnID); // index signature code already contains the loop\n                }\n\n                // required props that are simple expressions are restored as: '{a: deserializeA, b: deserializeB, c: deserializeC};\n                // and are serialized/deserialised in the same order they are declared in the type\n                const requiredItemsJit = required.map((prop) => comp.compile(prop, 'S', fnID));\n                const expressionItemsJit = requiredItemsJit\n                    .filter((childJit, i) => childIsExpression(childJit, required[i]))\n                    .map((prop) => prop.code)\n                    .filter(Boolean);\n                const statementItemsCode = requiredItemsJit\n                    .filter(Boolean)\n                    .filter((childJit, i) => !childIsExpression(childJit, required[i]))\n                    .map((prop) => prop.code);\n                const expressionsPropsCode = expressionItemsJit.join(',');\n                const requiredPropsCode = statementItemsCode.join(';');\n\n                // optional props are initialized as obj.a = deserializeA; obj.b = deserializeB; obj.c = deserializeC;\n                // bitmap is used to determine which optional props are present\n                // header format: [bitmap, optional props]\n                let optionalPropsCode = '';\n                if (optional.length) {\n                    // optional properties are restored using a loop\n                    const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, false);\n                    const propsCode = optional\n                        .map((prop, i) => {\n                            prop.optionalIndex = i;\n                            const modIndex = i + 1;\n                            const shouldIncreaseBufferIndex = modIndex % 8 === 0;\n                            const propCode = comp.compile(prop, 'S', fnID).code;\n                            if (!shouldIncreaseBufferIndex) return propCode;\n                            // every 8 props we need to increase the bitmap index\n                            return `${propCode} ${bitMIndexVar}++; `;\n                        })\n                        .filter(Boolean)\n                        .join('');\n                    const sep = requiredPropsCode ? ';' : '';\n                    optionalPropsCode = `${sep}\\n${bitMapInit}\\n${propsCode}`;\n                }\n\n                const canBeExpression = !requiredPropsCode && !optionalPropsCode;\n                if (canBeExpression) return {code: `{${expressionsPropsCode}}`, type: 'E'};\n                return {code: `${comp.vλl} = {${expressionsPropsCode}}\\n${requiredPropsCode}${optionalPropsCode}`, type: 'S'};\n            }\n        }\n        case ReflectionKind.class:\n            switch (runType.src.subKind) {\n                case ReflectionSubKind.date:\n                    return {code: `new Date(${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8)))`, type: 'E'};\n                case ReflectionSubKind.map:\n                case ReflectionSubKind.set: {\n                    const rt = runType as IterableRunType;\n                    const children = rt.getJitChildren(comp);\n                    const vλl = rt.getCustomVλl(comp)?.vλl || comp.vλl;\n                    const initCode = `const ${vλl} = new ${rt.constructorName}()`;\n                    if (!children.length) return {code: `new ${rt.constructorName}()`, type: 'E'};\n                    const childrenCode = children\n                        .map((c) => comp.compile(c, 'S', fnID).code)\n                        .filter(Boolean)\n                        .join(';');\n                    if (!childrenCode) return {code: initCode, type: 'E'};\n                    const index = comp.getLocalVarName('itI', rt);\n                    const lengthVar = comp.getLocalVarName('itL', rt);\n                    const readLength = `const ${lengthVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4`;\n                    return {\n                        code: `${initCode}; ${readLength}; for (let ${index} = 0; ${index} < ${lengthVar}; ${index}++) {${childrenCode}} ${comp.vλl} = ${vλl};`,\n                        type: 'S',\n                    };\n                }\n                case ReflectionSubKind.nonSerializable:\n                    throw new Error('Binary deserialization disabled for Non Serializable types');\n                default: {\n                    const rt = runType as ClassRunType;\n                    if (rt.isCallable()) {\n                        const callSignature = rt.getCallSignature();\n                        if (callSignature) return comp.compile(callSignature, 'S', fnID);\n                    }\n                    const originalKind = rt.src.kind;\n                    (runType.src as any).kind = ReflectionKind.objectLiteral;\n                    const plainObjCode = emitFromBinary(rt, comp);\n                    (runType.src as any).kind = originalKind;\n                    const desFnVarName = comp.getLocalVarName('desFn', rt);\n                    const desFnInit = `let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${toLiteral(rt.getClassName())})`;\n                    const desFnCode = `if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}`;\n                    const desClassCode = `else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${toLiteral(rt.getClassName())})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}`;\n                    const initCode = plainObjCode.type === 'E' ? `${comp.vλl} = ${plainObjCode.code}` : plainObjCode.code;\n                    return {code: `${initCode};${desFnInit};${desFnCode} ${desClassCode}`, type: 'S'};\n                }\n            }\n            break;\n\n        case ReflectionKind.infer:\n            throw new Error('Infer is not supported in Binary deserialization');\n\n        case ReflectionKind.tuple: {\n            const rt = runType as TupleRunType;\n            const skip = rt.skipJit(comp);\n            if (skip) return {code: undefined, type: 'S'};\n            const params = rt.getParamRunTypes(comp);\n\n            // For function params, all params are treated as optional in binary serialization\n            // This allows sending null/undefined values over the wire even if the type is not optional\n            const isFnParams = runType.src.subKind === ReflectionSubKind.params;\n\n            // For function params, all params are optional so we can't use fixed size\n            const hasFixedSize = !isFnParams && params.every((p) => !p.isOptional() && !p.isRest());\n            const initTuple = hasFixedSize ? `${comp.vλl} = new Array(${params.length});` : `${comp.vλl} = [];`;\n            if (params.length === 0) return {code: initTuple, type: 'S'};\n\n            // Split params into required, optional, and rest\n            // For function params, all non-rest params are treated as optional\n            const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());\n            const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());\n            const rest = params.filter((p) => p.isRest());\n\n            // Deserialize required params first\n            const requiredCode = required.map((p) => comp.compile(p, 'S', fnID).code || '').join(';');\n\n            // Deserialize optional params with bitmap (groups of 8)\n            let optionalCode = '';\n            if (optional.length) {\n                const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, true);\n                const optionalParamsCode = optional\n                    .map((p, i) => {\n                        (p as any).optionalIndex = i; // set optionalIndex for use in tupleMember case\n                        (p as any)._bitmapVar = bitMIndexVar; // pass bitmap variable name to tupleMember case\n                        (p as any)._isFnParam = isFnParams; // flag to indicate this is a function param\n                        const paramCode = comp.compile(p, 'S', fnID).code || '';\n                        const modIndex = i + 1;\n                        const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;\n                        const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : '';\n                        return `${paramCode} ${increaseIndex}`;\n                    })\n                    .join('');\n                optionalCode = `${bitMapInit}\\n${optionalParamsCode}`;\n            }\n\n            // Deserialize rest params (handled as array by the rest param itself)\n            const restCode = rest.map((p) => comp.compile(p, 'S', fnID).code || '').join(';');\n\n            const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(';');\n            return {code: `${initTuple}${allCode}`, type: 'S'};\n        }\n        case ReflectionKind.typeParameter:\n            throw new Error('Type parameter not implemented in Binary deserialization');\n\n        case ReflectionKind.union: {\n            const rt = runType as UnionRunType;\n            rt.checkAllowedChildren(comp);\n            const decVar = comp.getLocalVarName('dec', rt);\n            const errVarName = comp.getLocalVarName('uErr', rt);\n            comp.setContextItem(errVarName, `const ${errVarName} = \"Can not binary decode union: invalid union index\"`);\n            const children = rt.getJitChildren(comp);\n            if (children.length > MAX_UNION_ITEMS) {\n                throw new Error(\n                    `Binary deserialization not supported for Union with more than ${MAX_UNION_ITEMS} items.` +\n                        ` Found ${children.length} in ${rt.getUnionTypeNames()}`\n                );\n            }\n            const maxIndex = children.length - 1;\n            const isUint16 = maxIndex > 255;\n            const readIndex = isUint16\n                ? `const ${decVar} = ${dεs}.view.getUint16(${dεs}.index, 1); ${dεs}.index += 2;`\n                : `const ${decVar} = ${dεs}.view.getUint8(${dεs}.index++);`;\n            const ifElse = createIfElseFn();\n            const itemsCode = children\n                .map((unionItem) => {\n                    const childJit = comp.compile(unionItem, 'S', fnID);\n                    const isExpression = childIsExpression(childJit, unionItem);\n                    const code =\n                        isExpression && childJit.code && childJit.code !== comp.vλl\n                            ? `${comp.vλl} = ${childJit.code}`\n                            : childJit.code || '';\n                    const index = rt.getUnionItemIndex(comp, unionItem);\n                    return `${ifElse()} (${decVar} === ${index}) {${code || '/*noop*/'}}`;\n                })\n                .filter(Boolean);\n            const childrenCode = itemsCode.join('');\n            const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : '';\n            const code = `\n                ${readIndex}\n                ${childrenCode}\n                ${failCode}\n            `;\n            return {code, type: 'S'};\n        }\n\n        default:\n            throw new Error(`Binary deserialization not supported for ${ReflectionKind[kind]} types`);\n    }\n    throw new Error(`Do not know how to deserialize ${runType.getTypeName()} from Binary.`);\n}\n\nfunction getPropName(rt: PropertyRunType, comp: BinaryCompiler, isObjectConstructor: boolean): string | number {\n    const isSafe = isSafePropName(rt.src.name);\n    if (isObjectConstructor) return isSafe ? rt.getChildVarName(comp) : rt.getChildLiteral(comp);\n    return isSafe ? `.${rt.getChildVarName(comp)}` : `[${rt.getChildLiteral(comp)}]`;\n}\n\n/** Generates bitmap reading code for optional properties/params. Uses 1 bit per optional item (8 items per byte). */\nfunction getOptionalBitmapItems(\n    rt: InterfaceRunType | TupleRunType,\n    comp: BinaryCompiler,\n    optionalLength = 0,\n    currentIndex = 0,\n    isTuple = false\n) {\n    const dεs = comp.args.dεs;\n    const prefix = isTuple ? 't' : '';\n    const bitMIndexVar = comp.getLocalVarName(`${prefix}bimI`, rt); // index of the bitmap\n    const bitmapLength = Math.ceil(optionalLength / 8);\n    const bitIndex = `${currentIndex} & 7`; // equivalent to index % 8\n    // bitmap for present optional items\n    const bitMapInit = `${bitmapLength > 1 ? 'let ' : 'const'} ${bitMIndexVar} = ${dεs}.index; ${dεs}.index += ${bitmapLength};`;\n    return {bitMIndexVar, bitmapLength, bitIndex, bitMapInit};\n}\n\nfunction emitFromBinaryAs(rt: BaseRunType, comp: BinaryCompiler, kind: ReflectionKind): JitCode {\n    const originalKind = rt.src.kind;\n    (rt.src as any).kind = kind;\n    const result = emitFromBinary(rt, comp);\n    (rt.src as any).kind = originalKind;\n    return result;\n}\n"],"names":["JitFunctions","ReflectionKind","toLiteral","childIsExpression","ReflectionSubKind","getJitUtils","MAX_UNION_ITEMS","createIfElseFn","code","isSafePropName"],"mappings":"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"}

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

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