@mionjs/run-types 0.8.10 → 0.13.2

package/src/jitCompilers/json/toJsCode.ts

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