@mionjs/run-types 0.8.6 → 0.8.8

package/src/lib/jitFnsRegistry.ts

@@ -0,0 +1,53 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {JitFnID} from '../types.ts';
+import {JitFnSettings, jitFunctionList, jitFunctionsById} from '../constants.functions.ts';
+
+type resolvedCompiler = {
+    jitFnSettings: JitFnSettings;
+    compiler: (...args: any[]) => any;
+};
+
+const jitFunctionsRegistry: Map<string, resolvedCompiler> = new Map();
+const nativeIds: Set<string> = new Set(jitFunctionList.filter((f) => !f.import).map((f) => f.id));
+
+export async function registerJitFunctionCompiler(jitFnSettings: JitFnSettings): Promise<(...args: any[]) => any> {
+    const existing = jitFunctionsRegistry.get(jitFnSettings.id);
+    if (nativeIds.has(jitFnSettings.id))
+        throw new Error(`Jit function ${jitFnSettings.name} is native and can not be registered`);
+    if (existing) return existing.compiler;
+    if (!jitFnSettings.import) throw new Error(`Jit function ${jitFnSettings.name} has no import function`);
+    try {
+        const newFn = await jitFnSettings.import();
+        jitFunctionsRegistry.set(jitFnSettings.id, {
+            jitFnSettings: jitFnSettings,
+            compiler: newFn,
+        });
+        return newFn;
+    } catch (e: any) {
+        console.warn(e);
+        throw new Error(`Error loading jit function ${jitFnSettings.name}: ${e?.message}`);
+    }
+}
+
+/** synchronous version of loadRegisteredFunction, throws an error if the function has not been loaded */
+export function getJitFunctionCompiler(jitFnSettings: JitFnSettings): (...args: any[]) => any {
+    const existing = jitFunctionsRegistry.get(jitFnSettings.id);
+    if (existing) return existing.compiler;
+    throw new Error(`Function ${jitFnSettings.name} has not been loaded.`);
+}
+
+export function getJitFnSettings(fnID: JitFnID): JitFnSettings {
+    const fnConfig = jitFunctionsById[fnID] || jitFunctionsRegistry.get(fnID)?.jitFnSettings;
+    if (fnConfig === undefined) throw new Error(`Unknown jit function id: ${fnID}`);
+    return fnConfig;
+}
+
+export function getJITFnName(fnID: JitFnID): string {
+    return getJitFnSettings(fnID).name;
+}

package/src/lib/typeId.ts

@@ -0,0 +1,225 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {Type, TypeIndexSignature, TypeProperty, ReflectionKind, TypeClass, typeAnnotation} from '@deepkit/type';
+import {MAX_STACK_DEPTH, TypeFormatParams} from '@mionjs/core';
+import {ReflectionSubKind} from '../constants.kind.ts';
+import {hasType, hasTypes, hasParameters} from './guards.ts';
+import {getFormatterFromCache, defaultIgnoreFormatProps} from './formats.ts';
+import {typeParamsToString} from './utils.ts';
+import type {FormatAnnotation, SrcType, StrNumber} from '../types.ts';
+
+/** Type with optional cached _typeId and _formatId properties - compatible with SrcType */
+export type TypeWithCachedIds = Type & Pick<Partial<SrcType>, '_typeId' | '_formatId'>;
+
+/** Generates a unique type ID directly from a deepkit Type object. Caches result in type._typeId */
+export function createTypeId(type: TypeWithCachedIds, stack: Type[] = []): StrNumber {
+    if (type._typeId !== undefined) return type._typeId;
+    const typeId = _createTypeId(type, stack);
+    (type as any)._typeId = typeId;
+    return typeId;
+}
+
+function _createTypeId(type: Type, stack: Type[]): StrNumber {
+    if (stack.length > MAX_STACK_DEPTH) {
+        throw new Error(`Max stack depth exceeded while computing type ID. This usually indicates a circular type reference.`);
+    }
+    const circularId = checkCircularAndGetRefId(type, stack);
+    if (circularId !== undefined) return circularId;
+    const kind = (type as any).subKind || type.kind;
+    const baseTypeId = computeBaseTypeId(type, kind, stack);
+    const formatId = computeDeepkitFormatID(type as TypeWithCachedIds);
+    if (formatId) return `${baseTypeId}${formatId}`;
+    return baseTypeId;
+}
+
+function computeBaseTypeId(type: Type, kind: number, stack: Type[]): StrNumber {
+    const subKind = (type as any).subKind;
+    if (subKind === ReflectionSubKind.params) return computeParamsTypeId(type, stack);
+
+    switch (type.kind) {
+        // Atomic types - just return the kind
+        case ReflectionKind.any:
+        case ReflectionKind.bigint:
+        case ReflectionKind.boolean:
+        case ReflectionKind.never:
+        case ReflectionKind.null:
+        case ReflectionKind.number:
+        case ReflectionKind.object:
+        case ReflectionKind.regexp:
+        case ReflectionKind.string:
+        case ReflectionKind.symbol:
+        case ReflectionKind.undefined:
+        case ReflectionKind.unknown:
+        case ReflectionKind.void:
+        case ReflectionKind.enum:
+        case ReflectionKind.enumMember:
+        case ReflectionKind.promise:
+            return kind;
+        case ReflectionKind.literal: {
+            const literal = (type as any).literal;
+            return `${kind}:${String(literal)}`;
+        }
+        // Collection types - contain multiple child types
+        case ReflectionKind.union:
+        case ReflectionKind.intersection:
+        case ReflectionKind.objectLiteral:
+        case ReflectionKind.tuple:
+            return computeCollectionTypeId(type, stack);
+        // Member types - contain a single child type
+        case ReflectionKind.array:
+        case ReflectionKind.property:
+        case ReflectionKind.propertySignature:
+        case ReflectionKind.tupleMember:
+        case ReflectionKind.parameter:
+        case ReflectionKind.rest:
+        case ReflectionKind.indexSignature:
+            return computeMemberTypeId(type, stack);
+        // Function types
+        case ReflectionKind.function: {
+            const parent = type.parent;
+            const name = (type as any).name;
+            if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {
+                return `${ReflectionKind.function}${String(name)}`;
+            }
+            return ReflectionKind.function;
+        }
+        case ReflectionKind.method:
+        case ReflectionKind.methodSignature:
+        case ReflectionKind.callSignature:
+            return computeFunctionTypeId(type);
+        // Class types
+        case ReflectionKind.class:
+            return computeClassTypeId(type as TypeClass, stack);
+        default:
+            if (hasTypes(type)) return computeCollectionTypeId(type, stack);
+            if (hasType(type)) return computeMemberTypeId(type, stack);
+            return kind;
+    }
+}
+
+function computeCollectionTypeId(type: Type, stack: Type[]): StrNumber {
+    const types = (type as any).types as Type[] | undefined;
+    if (!Array.isArray(types)) return (type as any).subKind || type.kind;
+    stack.push(type);
+    const childIds: StrNumber[] = [];
+    for (const childType of types) childIds.push(_createTypeId(childType, stack));
+    stack.pop();
+    const isTuple = type.kind === ReflectionKind.tuple;
+    const groupID = isTuple ? `[${childIds.join(',')}]` : `{${childIds.join(',')}}`;
+    const kind = (type as any).subKind || type.kind;
+    return `${kind}${groupID}`;
+}
+
+function computeMemberTypeId(type: Type, stack: Type[]): StrNumber {
+    const memberType = (type as any).type as Type | undefined;
+    if (!memberType || typeof memberType.kind !== 'number') return (type as any).subKind || type.kind;
+    const isRest = memberType.kind === ReflectionKind.rest;
+    const isTupleParam = type.kind === ReflectionKind.tupleMember || type.kind === ReflectionKind.parameter;
+    const hasDefault = isTupleParam && (type as any).default !== undefined;
+    const optional = (type as any).optional || type.kind === ReflectionKind.indexSignature || isRest || hasDefault ? '?' : '';
+    const propName =
+        (type as TypeProperty).name?.toString() || (type as TypeIndexSignature).index?.kind || (type as any).subKind || type.kind;
+    const kindID = `${propName}${optional}`;
+    const circularId = checkCircularAndGetRefId(type, stack);
+    if (circularId) return `${kindID}:${circularId}`;
+    stack.push(type);
+    const memberTypeId = _createTypeId(memberType, stack);
+    stack.pop();
+    return `${kindID}:${memberTypeId}`;
+}
+
+function computeFunctionTypeId(type: Type): StrNumber {
+    const kind = ReflectionKind.function;
+    const parent = type.parent;
+    const name = (type as any).name;
+    let baseId: string;
+    if (name && parent && (parent.kind === ReflectionKind.objectLiteral || parent.kind === ReflectionKind.class)) {
+        baseId = `${kind}${String(name)}`;
+    } else {
+        baseId = String(kind);
+    }
+    const isOptional = !!(type as any).optional;
+    return isOptional ? `${baseId}:?` : baseId;
+}
+
+function computeClassTypeId(type: TypeClass, stack: Type[]): StrNumber {
+    if (type.classType === Date) return ReflectionSubKind.date;
+    if (type.classType === Map) {
+        const args = type.arguments;
+        if (!args || args.length !== 2) return ReflectionSubKind.map;
+        stack.push(type);
+        const keyTypeId = _createTypeId(args[0], stack);
+        const valueTypeId = _createTypeId(args[1], stack);
+        stack.pop();
+        return `${ReflectionSubKind.map}{${ReflectionSubKind.mapKey}:${keyTypeId},${ReflectionSubKind.mapValue}:${valueTypeId}}`;
+    }
+    if (type.classType === Set) {
+        const args = type.arguments;
+        if (!args || args.length !== 1) return ReflectionSubKind.set;
+        stack.push(type);
+        const itemTypeId = _createTypeId(args[0], stack);
+        stack.pop();
+        return `${ReflectionSubKind.set}{${ReflectionSubKind.setItem}:${itemTypeId}}`;
+    }
+    const kind = (type as any).subKind || type.kind;
+    const types = (type as any).types as Type[] | undefined;
+    if (Array.isArray(types) && types.length > 0) {
+        stack.push(type);
+        const childIds = types.map((t) => _createTypeId(t, stack));
+        stack.pop();
+        return `${kind}{${childIds.join(',')}}`;
+    }
+    return kind;
+}
+
+function computeParamsTypeId(type: Type, stack: Type[]): StrNumber {
+    if (!hasParameters(type)) return (type as any).subKind || type.kind;
+    const circularId = checkCircularAndGetRefId(type, stack);
+    if (circularId) return circularId;
+    stack.push(type);
+    const childIds: StrNumber[] = [];
+    for (const param of type.parameters) childIds.push(_createTypeId(param, stack));
+    stack.pop();
+    const kind = (type as any).subKind || type.kind;
+    return `${kind}{${childIds.join(',')}}`;
+}
+
+function checkCircularAndGetRefId(type: Type, stack: Type[]): StrNumber | undefined {
+    const inStackIndex = stack.findIndex((t) => {
+        if (t === type) return true;
+        return t.id && type.id && t.id === type.id;
+    });
+    if (inStackIndex >= 0) {
+        const name = type.typeName || '';
+        return '$' + type.kind + `_${inStackIndex}` + name;
+    }
+    return undefined;
+}
+
+/** Computes the format ID from a deepkit Type. Caches result in type._formatId */
+export function computeDeepkitFormatID(deepkitType: TypeWithCachedIds): string | undefined {
+    if (deepkitType._formatId !== undefined) return deepkitType._formatId || undefined;
+    const annotations = typeAnnotation.getAnnotations(deepkitType);
+    if (annotations.length === 0) {
+        (deepkitType as any)._formatId = '';
+        return undefined;
+    }
+    for (const annotation of annotations) {
+        const formatAnnotation = annotation as FormatAnnotation;
+        if (!formatAnnotation.name) continue;
+        const formatter = getFormatterFromCache(deepkitType.kind, formatAnnotation.name);
+        if (!formatter) continue;
+        const params = typeAnnotation.getOption(deepkitType, formatAnnotation.name) as TypeFormatParams;
+        if (!params) continue;
+        const formatId = `<${typeParamsToString(params, defaultIgnoreFormatProps)}>`;
+        (deepkitType as any)._formatId = formatId;
+        return formatId;
+    }
+    (deepkitType as any)._formatId = '';
+    return undefined;
+}

package/src/lib/utils.ts

@@ -0,0 +1,402 @@
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {ReflectionKind} from '@deepkit/type';
+import type {Type, TypeFunction, TypeParameter, TypeTuple, TypeTupleMember} from '@deepkit/type';
+import type {CompiledPureFunction, TypeFormatValue} from '@mionjs/core';
+import type {AnyClass, JitFnID, RunType} from '../types.ts';
+import type {BaseRunType, CollectionRunType, MemberRunType} from './baseRunTypes.ts';
+import type {JitFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';
+import type {PropertyRunType} from '../nodes/member/property.ts';
+import {createHashLiteral} from '@mionjs/core';
+import {validPropertyNameRegExp} from '../constants.ts';
+import {ReflectionSubKind} from '../constants.kind.ts';
+import {getJitFnSettings} from './jitFnsRegistry.ts';
+import type {JitCode} from '../types.ts';
+
+export function toLiteral(value: number | string | boolean | undefined | null | bigint | RegExp | symbol): string {
+    switch (typeof value) {
+        case 'number':
+            return `${value}`;
+        case 'string':
+            return JSON.stringify(value);
+        case 'boolean':
+            return value ? 'true' : 'false';
+        case 'undefined':
+            return 'undefined';
+        case 'bigint':
+            return `${value}n`;
+        case 'symbol':
+            return `Symbol(${toLiteral(value.description)})`;
+        case 'object':
+            if (value === null) return 'null';
+            if (value instanceof RegExp) return value.toString();
+            throw new Error(`Unsupported literal type ${value}`);
+        default:
+            throw new Error(`Unsupported literal type ${value}`);
+    }
+}
+
+export function arrayToLiteral(value: any[]): string {
+    return `[${arrayToArgumentsLiteral(value)}]`;
+}
+
+export function arrayToArgumentsLiteral(value: any[]): string {
+    return value.map((v) => `${toLiteral(v)}`).join(', ');
+}
+
+export function isFunctionKind(kind: ReflectionKind): boolean {
+    return (
+        kind === ReflectionKind.callSignature ||
+        kind === ReflectionKind.method ||
+        kind === ReflectionKind.function ||
+        kind === ReflectionKind.methodSignature ||
+        kind === ReflectionKind.indexSignature
+    );
+}
+
+export function isClass(cls: AnyClass | any): cls is AnyClass {
+    return (
+        typeof cls === 'function' &&
+        cls.prototype &&
+        cls.prototype.constructor === cls &&
+        cls.prototype.constructor.name &&
+        cls.toString().startsWith('class')
+    );
+}
+
+export function isSameJitType(a: RunType, b: RunType): boolean {
+    if (a === b) return true;
+    if (a.src.kind !== b.src.kind) return false;
+    return a.getTypeID() === b.getTypeID();
+}
+
+export function isSameJitCompiler(a: JitFnCompiler, b: JitFnCompiler): boolean {
+    return a.fnID === b.fnID && isSameJitType(a.rootType, b.rootType);
+}
+
+export function memorize<Fn extends (...args: any[]) => any>(fn: Fn): Fn {
+    let cached: undefined | any;
+    return ((...args: any[]) => {
+        if (!cached) cached = fn(...args);
+        return cached;
+    }) as Fn;
+}
+
+export function isSafePropName(name: string | number | symbol): boolean {
+    return (typeof name === 'string' && validPropertyNameRegExp.test(name)) || typeof name === 'number';
+}
+
+export function sanitizePropName(name: string | number | symbol): string {
+    const sName = typeof name === 'string' ? name : String(name);
+    return sName.replace(/[^a-zA-Z0-9_$]/g, '_');
+}
+
+export function getPropVarName(name: string | number | symbol): string | number {
+    if (typeof name === 'symbol') return name.toString();
+    return name;
+}
+export function getPropLiteral(name: string | number | symbol): string | number {
+    return toLiteral(name);
+}
+export function useArrayAccessorForProp(name: string | number | symbol): boolean {
+    if (typeof name === 'number') return true;
+    return !isSafePropName(name);
+}
+
+export function getPropIndex(src: Type): number {
+    const parent = src.parent;
+    if (!parent) return -1;
+    const types = (parent as {types: Type[]}).types;
+    if (types) return types.indexOf(src);
+    return 0;
+}
+
+export function getParamIndex(src: TypeParameter | TypeTupleMember): number {
+    const parent = src.parent as TypeFunction | TypeTuple;
+    if (!parent) return -1;
+    if ((parent as TypeFunction).parameters) return (parent as TypeFunction).parameters.indexOf(src as TypeParameter);
+    if ((parent as TypeTuple).types) return (parent as TypeTuple).types.indexOf(src as TypeTupleMember);
+    return 0;
+}
+
+export function childIsExpression(childJCode: JitCode, child: BaseRunType): boolean {
+    return childJCode.type === 'E' || !child.isJitInlined();
+}
+
+// ######### To literal with context ########
+
+const maxStringLength = 10;
+
+/**
+ * Transforms values into a literal string to be used in JIT code.
+ * ie: {total: 5, name: 'hello'} gets transformed into teh string '{total: 5, name: "hello"}' that can be used as JIT code.
+ * Some literals are automatically added to the context to reduce code size. in this case the reference to the context variable is returned.
+ * Otherwise the literal is returned.
+ *
+ * Important this is intended for actual immutable literals, if two empty arrays are passed they will be transformed into the same reference.
+ * so those object or arrays should never be modified in jit code. //TODO: investigate using object.freeze
+ *
+ * @param comp
+ * @param params
+ * @param ignoreProps
+ * @param isDependencies
+ * @returns
+ */
+export function toLiteralInContext(
+    // if compiled is passed it is assumed that the params are dependencies and will be transformed into code
+    comp: JitFnCompiler | JitErrorsFnCompiler,
+    params: TypeFormatValue | Record<string, string | CompiledPureFunction>,
+    // TODO: somewhere the ignoreProps are not passed and we still outputting 'samples' and 'sampleChars' to jit code were is not needed
+    ignoreProps: string[] = [],
+    isDependencies = false
+): string {
+    switch (true) {
+        case typeof params === 'string': {
+            const literal = toLiteral(params);
+            // if string is longer than 10 chars we add it as a new variable in the context to reduce code size
+            if (params.length > maxStringLength) {
+                const hash = createHashLiteral(params);
+                const strName = hash;
+                if (!comp.hasContextItem(strName)) comp.setContextItem(strName, `const ${strName} = ${literal}`);
+                return strName;
+            }
+            return literal;
+        }
+        case typeof params === 'number':
+            return `${params}`;
+        case typeof params === 'boolean':
+            return params ? 'true' : 'false';
+        case params instanceof RegExp: {
+            // if param is a regexp we add it as a new variable in the context (so we are not creating a new regexp on each call)
+            const regCode = params.toString();
+            const hash = createHashLiteral(regCode);
+            const regName = hash;
+            if (!comp.hasContextItem(regName)) comp.setContextItem(regName, `const ${regName} = ${regCode}`);
+            return regName;
+        }
+        case Array.isArray(params): {
+            // arrays are added to the context as a new variable
+            const arrCode = `[${params.map((v) => toLiteralInContext(comp, v, ignoreProps, isDependencies)).join(',')}]`;
+            const hash = createHashLiteral(arrCode);
+            const arrName = hash;
+            if (!comp.hasContextItem(arrName)) comp.setContextItem(arrName, `const ${arrName} = ${arrCode}`);
+
+            return arrName;
+        }
+        case typeof params === 'object': {
+            // objects are added to the context as a new variable
+            const entriesLiterals = Object.entries(params).map(([k, v]) => {
+                if (ignoreProps.includes(k) || typeof v === 'undefined') return undefined;
+                const propName = isSafePropName(k) ? k : toLiteral(k);
+                if (!isDependencies) return `${propName}:${toLiteralInContext(comp, v, ignoreProps, isDependencies)}`;
+                return `${propName}:${dependencyValueToLiteral(comp, v)}`;
+            });
+            const objCode = `{${entriesLiterals.filter(Boolean).join(',')}}`;
+            const hash = createHashLiteral(objCode);
+            const objName = hash;
+            if (!comp.hasContextItem(objName)) comp.setContextItem(objName, `const ${objName} = ${objCode}`);
+            return objName;
+        }
+        case typeof params === 'bigint':
+            return toLiteral(params);
+        default:
+            throw new Error(`Unsupported type format params ${params}`);
+    }
+}
+
+export function dependencyValueToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler | undefined, propVal: any): string {
+    if (
+        typeof propVal === 'object' &&
+        propVal !== null &&
+        'createJitFn' in propVal &&
+        'namespace' in propVal &&
+        'fnName' in propVal
+    ) {
+        // propVal is a CompiledPureFunction
+        if (!comp) throw new Error('Dependencies must be pure functions or code');
+        comp.addPureFnDependency(propVal);
+        return `utl.getPureFn(${toLiteral(propVal.namespace)}, ${toLiteral(propVal.fnName)})`;
+    }
+    if (typeof propVal === 'string') return propVal;
+    throw new Error('Dependencies must be CompiledPureFunction objects or code strings');
+}
+
+export function typeParamsToString(
+    params: TypeFormatValue | Record<string, string | CompiledPureFunction>,
+    ignoreProps: string[]
+): string {
+    switch (true) {
+        case typeof params === 'string':
+            return toLiteral(params);
+        case typeof params === 'number':
+            return `${params}`;
+        case typeof params === 'boolean':
+            return params ? 'true' : 'false';
+        case params instanceof RegExp:
+            return params.toString();
+        case Array.isArray(params):
+            return `[${params.map((v) => typeParamsToString(v, ignoreProps)).join(', ')}]`;
+        case typeof params === 'object': {
+            const entriesLiterals = Object.entries(params).map(([k, v]) => {
+                if (ignoreProps.includes(k) || typeof v === 'undefined') return undefined;
+                return `${k}:${typeParamsToString(v, ignoreProps)}`;
+            });
+            return `{${entriesLiterals.filter(Boolean).join(',')}}`;
+        }
+        case typeof params === 'bigint':
+            return `${params}n`;
+        default:
+            throw new Error(`Unsupported type format params ${params}`);
+    }
+}
+export function getFormatterHash(rt: BaseRunType): string {
+    const literal = rt.getFormatTypeID();
+    if (!literal) throw new Error('Formatter JIT ID not found');
+    return createHashLiteral(literal);
+}
+
+/** Complexity of each type family, we can add more types and weights here if we want to optimize further */
+const familyComplexity = {
+    A: 2,
+    M: 20, // member usually involves iteration
+    C: 10, // collection usually involves calling and extra jit function
+    F: 10_000_000,
+}; // function should go always last
+const typesComplexity = {
+    [ReflectionKind.indexSignature]: 20, // index involves traversing all object keys
+    [ReflectionKind.array]: 30, // array involves iterating all items
+    [ReflectionKind.property]: 0, // property involves just checking a single property
+    [ReflectionKind.propertySignature]: 0, // property involves just checking a single property
+    [ReflectionKind.boolean]: 1, // boolean is fast to check
+    [ReflectionKind.null]: 1, // null is fast to check
+    [ReflectionKind.undefined]: 1, // undefined is fast to check
+    [ReflectionKind.enum]: 20, // enum can involve checking multiple values
+};
+const subTypesComplexity = {
+    [ReflectionSubKind.date]: 3,
+};
+
+/**
+ * Returns an arbitrary complexity number for a runType, this depends on the type family and the complexity of all children.
+ * There might be better options to get the type complexity, as this also depends on the runtime operation and the compiled operation.
+ * but this is an initial approximation.
+ */
+export function getTotalComplexity(comp: JitFnCompiler, rt: BaseRunType, stack: BaseRunType[] = []): number {
+    if (!rt) return 0;
+    if (stack.includes(rt)) return 0;
+    stack.push(rt);
+    let result = 0;
+    const subKindC = rt.src.subKind ? subTypesComplexity[rt.src.subKind] : undefined;
+    const typeC = subKindC || typesComplexity[rt.src.kind];
+    const familyC = rt.getFamily();
+    if (familyC === 'A') result = typeC || familyComplexity.A;
+    else if (familyC === 'M') {
+        const childRT = (rt as MemberRunType<any>).getJitChild(comp);
+        if (!childRT) return typeC ?? familyComplexity.M;
+        const childC = getTotalComplexity(comp, childRT, stack);
+        result = (typeC ?? familyComplexity.M) + childC;
+    } else if (familyC === 'C') {
+        const childrenC = (rt as CollectionRunType<any>)
+            .getJitChildren(comp)
+            .map((child) => getTotalComplexity(comp, child, stack));
+        const totalChildrenC = childrenC.reduce((acc, childC) => acc + childC, 0);
+        result = (typeC ?? familyComplexity.C) + totalChildrenC;
+    } else {
+        result = typeC ?? familyComplexity.F;
+    }
+    stack.pop();
+    return result;
+}
+
+/**
+ * Sort runTypes by complexity, ascending. this way less complex code can be executed first.
+ * This could help to fail fast and avoid unnecessary checks.
+ */
+export function sortRunTypeByComplexity(comp: JitFnCompiler, a: BaseRunType, b: BaseRunType): number {
+    if (a.getFamily() === 'M' && b.getFamily() === 'M') {
+        const aIsDiscriminator = (a as PropertyRunType).isUnionDiscriminator;
+        const bIsDiscriminator = (b as PropertyRunType).isUnionDiscriminator;
+        if (aIsDiscriminator && !bIsDiscriminator) return -1;
+        if (!aIsDiscriminator && bIsDiscriminator) return 1;
+    }
+    if (b.getFamily() === 'M' && (b as PropertyRunType).isUnionDiscriminator) return 1;
+    const aTotal = getTotalComplexity(comp, a);
+    const bTotal = getTotalComplexity(comp, b);
+    return aTotal - bTotal;
+}
+
+export function sortDiscriminatorsFirst(a: BaseRunType, b: BaseRunType): number {
+    if (a.getFamily() === 'M' && b.getFamily() === 'M') {
+        const aIsDiscriminator = (a as PropertyRunType).isUnionDiscriminator;
+        const bIsDiscriminator = (b as PropertyRunType).isUnionDiscriminator;
+        if (aIsDiscriminator && !bIsDiscriminator) return -1;
+        if (!aIsDiscriminator && bIsDiscriminator) return 1;
+    }
+    return 0;
+}
+
+export function createIfElseFn(): (isEnd?: boolean) => string {
+    let isFirst = true;
+    return (end = false) => {
+        const elseIf = end ? 'else' : 'else if';
+        const iF = isFirst ? 'if' : elseIf;
+        isFirst = false;
+        return iF;
+    };
+}
+
+export function getJitFnArgCallVarName(parentComp: JitFnCompiler, rt: BaseRunType, idFnToCall: JitFnID, argKey: string): string {
+    const fnConfig = getJitFnSettings(idFnToCall);
+    const defaultArgVal = fnConfig.jitDefaultArgs[argKey];
+    // vλl is a special case because it is the only arg that changes based on the stack
+    if (argKey === 'vλl' && fnConfig.noInitialVλl) return 'undefined'; // when no initial vλl is required, we pass undefined
+    if (argKey === 'vλl') return parentComp.getCurrentStackItem().vλl; // when vλl is required we pass the current stack item
+
+    // first check if the arg is provided by the context
+    const varNameFromContext = parentComp.getChildrenCallArgs(idFnToCall)?.[argKey];
+    if (varNameFromContext) return varNameFromContext;
+    // then check if the arg is provided by the parent function
+    const varNameFromParent = parentComp.args[argKey];
+    if (varNameFromParent) return varNameFromParent;
+    // if neither the parent nor the context has the arg, we create a new default value in the context
+    // if there is no default value, we can't call the function
+    if (!defaultArgVal)
+        throw new Error(
+            `Can not call jit function ${idFnToCall} because it requires argument ${argKey} but it is not provided,
+            neither in the parent function nor in the function context and there is no default value for it.`
+        );
+    const defaultName = fnConfig.jitArgs[argKey];
+    const optsVarName = `${defaultName}_${idFnToCall}0`; // we don't need to use nestLevel as value is the same for all calls
+    parentComp.setContextItem(optsVarName, `const ${optsVarName} = ${defaultArgVal}`);
+    return optsVarName;
+}
+
+/**
+ * Returns true if the parent of the runType is of the given kind.
+ * handles special case of union types, as we need to check the parent of the union.
+ * @param rt
+ * @param kind
+ * @returns
+ */
+export function parentIs(rt: BaseRunType, kind: ReflectionKind | ReflectionKind[]): boolean {
+    const parentRT = rt.getParent();
+    if (!parentRT) return false;
+    if (parentRT.src.kind === ReflectionKind.union) return parentIs(parentRT, kind);
+    if (Array.isArray(kind) ? kind.includes(parentRT.src.kind) : parentRT.src.kind === kind) return true;
+    return false;
+}
+
+/** Add full stop to code if needed */
+export function addFullStop(code: string): string {
+    if (!code) return code;
+    const lastChar = code.length - 1;
+    const hasFullStop = code[lastChar] === ';';
+    if (hasFullStop) return code;
+    const hasBlockClose = code[lastChar] === '}';
+    return hasBlockClose ? code : `${code};`;
+}