@mionjs/run-types 0.8.6 → 0.8.8

package/src/lib/createJitFunction.ts

@@ -0,0 +1,87 @@
+import {getENV, getJitUtils, type JITUtils} from '@mionjs/core';
+import type {JitFnID, Mutable, RunTypeOptions} from '../types.ts';
+import {BaseFnCompiler, JitCompilerLike, printClosure} from './jitFnCompiler.ts';
+import type {BaseRunType} from './baseRunTypes.ts';
+import {getJITFnName} from './jitFnsRegistry.ts';
+
+/**
+ * Creates a function name/hash based on the jitHash of the runType and the id of the function.
+ * it is a valid js variable name.
+ * @param id
+ * @param rt
+ * @returns
+ */
+export function getJITFnHash(id: JitFnID, rt: BaseRunType, opts?: RunTypeOptions): string {
+    if (opts) return `${id}_${rt.getJitHash(opts)}`;
+    return `${id}_${rt.getJitHash({})}`;
+}
+
+/**
+ * Creates a jit function from a compiler.
+ * This function handles the logic to determine if the function should be created or retrieved from the cache.
+ * @param comp
+ * @returns
+ */
+export function createJitFunction(comp: BaseFnCompiler): (...args: any[]) => any {
+    if (comp.fn) return comp.fn;
+    if (comp.stack.length !== 0) throw new Error('Can not get compiled function before the compile operation is finished');
+    if (getJitUtils().hasJitFn(comp.jitFnHash)) return getJitUtils().getJitFn(comp.jitFnHash);
+    const {fnCode, fnName, contextCode} = getJitFnCode(comp);
+    const {createJitFn, fn, code} = createJitFnWithContext(comp, fnName, fnCode, contextCode);
+    (comp as Mutable<BaseFnCompiler>).code = code;
+    (comp as Mutable<BaseFnCompiler>).fn = fn;
+    (comp as Mutable<BaseFnCompiler>).createJitFn = createJitFn;
+    return fn;
+}
+
+/**
+ * Create a JIT function that has jitUtils (and possibly other required variables) in the context,
+ * This way jitUtils ca be used without passing them as arguments to every atomic jit function (kind of global variables).
+ * @param varName
+ * @param fnCode
+ * @returns
+ */
+function createJitFnWithContext(comp: BaseFnCompiler, fnName: string, fnCode: string, contextCode?: string) {
+    // this function will have jitUtils as context as is an argument of the enclosing function
+    const context = contextCode ? `${contextCode};` : '';
+    let fnWithContext = `'use strict'; ${context} return ${fnCode}`;
+    if (getENV('DEBUG_RUN_TIME')) {
+        const fnArgs = getJitFnArgs(comp);
+        const argsCall = getJitFnArgs(comp, false);
+        const debugWrapper = `function debug_${fnName}(${fnArgs}){
+            const resp = ${fnName}(${argsCall});
+            console.log('${fnName} ${getJITFnName(comp.fnID)} ${comp.rootType.getTypeName()}', 'result:', resp, ' value:', ${argsCall});
+            return resp;
+        }`;
+        fnWithContext = `'use strict'; ${context} ${fnCode} ${debugWrapper} return debug_${fnName};`;
+    }
+    try {
+        // wrapper functions that works as a factory and returns the actual jit function, context contains all constants and heavy to create objects
+        const wrapperWithContext = new Function('utl', fnWithContext) as (utl: JITUtils) => (...args: any[]) => any;
+        if (getENV('DEBUG_JIT')) console.log(printClosure(fnWithContext, fnName));
+        return {createJitFn: wrapperWithContext, fn: wrapperWithContext(getJitUtils()), code: fnWithContext}; // returns the jit internal function with the context
+    } catch (e: any) {
+        if (getENV('DEBUG_JIT')) {
+            console.warn('Error creating jit function with context code:\n', printClosure(fnWithContext, fnName));
+        }
+        throw e;
+    }
+}
+
+function getJitFnCode(comp: BaseFnCompiler): {fnName: string; fnCode: string; contextCode: string} {
+    const fnName = comp.jitFnHash;
+    const fnArgs = getJitFnArgs(comp); // function arguments with default values ie: 'vλl, pλth=[], εrr=[]'
+    const fnCode = `function ${fnName}(${fnArgs}){${comp.code}}`;
+    return {fnName, fnCode, contextCode: comp.getContextItemValues().join(';\n')};
+}
+
+/** Returns the arguments of the function with default values */
+function getJitFnArgs(comp: JitCompilerLike, defaultValues = true): string {
+    return Object.entries(comp.args)
+        .map(([key, name]) => {
+            if (!comp.defaultParamValues[key] || !defaultValues) return name;
+            const value = comp.defaultParamValues[key];
+            return `${name}=${value}`;
+        })
+        .join(',');
+}

package/src/lib/dkProxy.ts

@@ -0,0 +1,47 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {typeAnnotation, typeToObject} from '@deepkit/type';
+import {RunType, RunTypeAnnotation, SrcType} from '../types.ts';
+
+/**
+ * Returns RunType annotations, ie:
+ *
+ * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;
+ * const rt = runType<WithSuffix<'hello'>>();
+ * const annotations = rt.getRunTypeAnnotations();
+ * annotations = [{name: 'suffix', options: LiteralRunType<'hello'>}];
+ */
+export function getRunTypeAnnotations(rt: RunType): RunTypeAnnotation[] {
+    const annotations = typeAnnotation.getAnnotations(rt.src);
+    return annotations.map((a) => {
+        const annotation: RunTypeAnnotation = {
+            name: a.name,
+            options: (a.options as SrcType)._rt as RunType,
+        };
+        return annotation;
+    });
+}
+
+/**
+ * Returns the options of the annotations parsed js data, ie:
+ *
+ * type WithSuffix<Suffix extends string> = string & TypeAnnotation<'suffix', Suffix>;
+ * const rt = runType<WithSuffix<'hello'>>();
+ * const parsedOptions = rt.getParsedAnnotationOptions();
+ * parsedOptions = 'hello';
+ */
+export function getParsedAnnotationOptions(rt: RunType): any[] {
+    return getRunTypeAnnotations(rt).map((a) => typeAnnotation.getOption(rt.src, a.name));
+}
+
+/**
+ * Returns the deepkit type as a js object, this is useful to extract metadata from the type.
+ */
+export function getTypeToObject(rt: RunType): any {
+    return typeToObject(rt.src);
+}

package/src/lib/formats.ts

@@ -0,0 +1,144 @@
+/* ########
+ * 2025 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import {CompiledPureFunction, TypeFormatParams, TypeFormatValue} from '@mionjs/core';
+import {ReflectionKindName} from '../constants.kind.ts';
+import type {FormatAnnotation} from '../types.ts';
+import {typeAnnotation, ReflectionKind} from '@deepkit/type';
+import type {BaseRunType} from './baseRunTypes.ts';
+import type {JitErrorsFnCompiler, JitFnCompiler} from './jitFnCompiler.ts';
+import type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';
+import {toLiteralInContext} from './utils.ts';
+
+// ################# REGISTER FORMATTERS & PURE FUNCTIONS  #################
+
+const typeAnnotationsCache = new Map<string, BaseRunTypeFormat>();
+const formatterPrefix = 'f';
+
+/** Adds a TypeFormatter or TypeValidator to the formatters cache */
+export function registerFormatter<T extends BaseRunTypeFormat>(operation: T, shouldThrow = false): T {
+    const id = getFormatterKey(formatterPrefix, operation.kind, operation.name);
+    const exiting = typeAnnotationsCache.get(id);
+    if (exiting && exiting !== operation) {
+        if (shouldThrow)
+            throw new Error(`Annotation type ${operation.name} already registered for ${ReflectionKindName[operation.kind]}`);
+        return operation;
+    }
+    typeAnnotationsCache.set(id, operation);
+    return operation;
+}
+
+/** Gets a TypeFormatter or TypeValidator to the formatters cache */
+export function getFormatterFromCache(
+    typeKind: ReflectionKind,
+    name: string,
+    shouldThrow = false
+): BaseRunTypeFormat | undefined {
+    const formatter = typeAnnotationsCache.get(getFormatterKey(formatterPrefix, typeKind, name));
+    if (!formatter) {
+        if (shouldThrow) throw new Error(`Annotation type ${name} not found for ${ReflectionKindName[typeKind]}`);
+        return undefined;
+    }
+    return formatter;
+}
+
+export function getFormatterKey(prefix: string, kind: string | number, name: string | number): string {
+    return `${prefix}:${kind}:${name}`;
+}
+
+/** Returns the validator for a given type. ATM only one validator is allowed for each type */
+export function getRunTypeFormat(rt: BaseRunType): BaseRunTypeFormat | undefined {
+    return getFormatAnnotation(rt)?.formatter;
+}
+
+export function getRunTypeTransformer(rt: BaseRunType): BaseRunTypeFormat | undefined {
+    const rtFormat = getRunTypeFormat(rt);
+    if (rtFormat?.emitFormat) return rtFormat;
+    return undefined;
+}
+
+// ################# ANNOTATIONS  #################
+
+/**
+ * Reads deepkit annotations and augment them with the associated formatters.
+ * @param rt
+ * @returns
+ */
+export function initFormatAnnotations(rt: BaseRunType): FormatAnnotation | undefined {
+    const annotations = typeAnnotation.getAnnotations(rt.src);
+    if (annotations.length === 0) return;
+    if (annotations.length > 1)
+        throw new Error(`Only one type annotation is allowed for runTypes and ${rt.getTypeName()} has ${annotations.length}`);
+    const annotation = annotations[0] as FormatAnnotation;
+    if (!annotation.name) throw new Error(`Type annotation must have a name for ${rt.getTypeName()}`);
+    const params = annotation.options;
+    const formatter = getFormatterFromCache(rt.src.kind, annotation.name);
+    // formatter property is only added to registered formatters, this allows using other type annotations that are not formatters
+    if (formatter && params.kind === ReflectionKind.objectLiteral) {
+        annotation.formatter = formatter;
+        return annotation;
+    }
+    return annotation as FormatAnnotation;
+}
+
+/** Returns the params for a given type formatter */
+export function getFormatterParams<P extends TypeFormatParams>(rt: BaseRunType, fmtName: string): P {
+    const annotation = getFormatAnnotation(rt);
+    if (annotation?.name === fmtName) {
+        if (annotation.params) return annotation.params as P;
+        annotation.params = typeAnnotation.getOption(rt.src, annotation.name) as P;
+        return annotation.params as P;
+    }
+    throw new Error(`Type Formatter ${fmtName} not found for ${rt.getTypeName()}`);
+}
+
+export function getFormatAnnotation(rt: BaseRunType): FormatAnnotation | undefined {
+    const parsedAnnotations = typeAnnotation.getAnnotations(rt.src);
+    const formatAnnotations = parsedAnnotations.filter((a) => (a as FormatAnnotation).formatter);
+    return formatAnnotations[0] as FormatAnnotation | undefined;
+}
+
+// ################# COMPILING  #################
+
+// TODO, read ignoreProps from multiple formatters, rather than a constant here
+export const defaultIgnoreFormatProps = ['mockSamples'];
+
+/**
+ * Transforms a params object 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.
+ *
+ * @param comp
+ * @param params
+ * @param ignoreProps
+ * @returns
+ */
+export function paramsToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue, ignoreProps?: string[]) {
+    return toLiteralInContext(comp, params, ignoreProps, false);
+}
+
+export function getToLiteralFn(comp: JitFnCompiler | JitErrorsFnCompiler, ignoreProps?: string[]) {
+    return (params: TypeFormatValue) => paramsToLiteral(comp, params, ignoreProps);
+}
+
+/**
+ * Transforms a dependencies object into a string literal that can be used as JIT code.
+ * Dependencies object can contain pure functions or code.
+ * Pure functions will be load as dependency using jitUtils.getPureFn, and code will be left as is.
+ * ie: {helloFn: function hello(){}, code: 'v + 2'} gets transformed into the string '{helloFn: utl.getPureFn("hello"), code: v + 2}'
+ * @param comp
+ * @param params
+ * @param ignoreProps
+ * @returns
+ */
+export function dependenciesToLiteral(
+    comp: JitFnCompiler | JitErrorsFnCompiler,
+    params: Record<string, string | CompiledPureFunction>,
+    ignoreProps: string[] = []
+) {
+    return toLiteralInContext(comp, params, ignoreProps, true);
+}

package/src/lib/guards.ts

@@ -0,0 +1,290 @@
+/* eslint-disable no-case-declarations */
+/* ########
+ * 2024 mion
+ * Author: Ma-jerez
+ * License: MIT
+ * The software is provided "as is", without warranty of any kind.
+ * ######## */
+
+import type {Type, TypeClass, TypeMethod, TypeObjectLiteral, TypeParameter} from '@deepkit/type';
+import type {AnyClass, FormatParamMeta, TypeFormatValue} from '@mionjs/core';
+import {isType, ReflectionKind} from '@deepkit/type';
+import {ReflectionSubKind} from '../constants.kind.ts';
+import {nativeUtilityStringTypes, nonSerializableClasses, nonSerializableGlobals} from '../constants.ts';
+import {JitFunctions} from '../constants.functions.ts';
+/* IMPORTANT: import classes as type only to prevent js circular imports */
+import type {RunType, RunTypeChildAccessor} from '../types.ts';
+import type {StringRunType} from '../nodes/atomic/string.ts';
+import type {DateRunType} from '../nodes/atomic/date.ts';
+import type {NumberRunType} from '../nodes/atomic/number.ts';
+import type {BooleanRunType} from '../nodes/atomic/boolean.ts';
+import type {NullRunType} from '../nodes/atomic/null.ts';
+import type {BigIntRunType} from '../nodes/atomic/bigInt.ts';
+import type {AnyRunType} from '../nodes/atomic/any.ts';
+import type {UndefinedRunType} from '../nodes/atomic/undefined.ts';
+import type {UnknownRunType} from '../nodes/atomic/unknown.ts';
+import type {VoidRunType} from '../nodes/atomic/void.ts';
+import type {ArrayRunType} from '../nodes/member/array.ts';
+import type {LiteralRunType} from '../nodes/atomic/literal.ts';
+import type {RegexpRunType} from '../nodes/atomic/regexp.ts';
+import type {NeverRunType} from '../nodes/atomic/never.ts';
+import type {EnumRunType} from '../nodes/atomic/enum.ts';
+import type {EnumMemberRunType} from '../nodes/atomic/enumMember.ts';
+import type {UnionRunType} from '../nodes/collection/union.ts';
+import type {TupleRunType} from '../nodes/collection/tuple.ts';
+import type {TupleMemberRunType} from '../nodes/member/tupleMember.ts';
+import type {InterfaceRunType, InterfaceMember} from '../nodes/collection/interface.ts';
+import type {PropertyRunType} from '../nodes/member/property.ts';
+import type {IndexSignatureRunType} from '../nodes/member/indexProperty.ts';
+import type {MethodSignatureRunType} from '../nodes/member/methodSignature.ts';
+import type {CallSignatureRunType} from '../nodes/member/callSignature.ts';
+import type {FunctionRunType} from '../nodes/function/function.ts';
+import type {FunctionParamsRunType} from '../nodes/collection/functionParams.ts';
+import type {ParameterRunType} from '../nodes/member/param.ts';
+import type {PromiseRunType} from '../nodes/native/promise.ts';
+import type {ObjectRunType} from '../nodes/atomic/object.ts';
+import type {MethodRunType} from '../nodes/member/method.ts';
+import type {AtomicRunType, CollectionRunType, MemberRunType} from './baseRunTypes.ts';
+import type {BaseFnCompiler, JitErrorsFnCompiler} from './jitFnCompiler.ts';
+import type {ClassRunType} from '../nodes/collection/class.ts';
+import type {IntersectionRunType} from '../nodes/collection/intersection.ts';
+import type {SymbolRunType} from '../nodes/atomic/symbol.ts';
+
+export function isAnyRunType(rt: RunType): rt is AnyRunType {
+    return rt.src.kind === ReflectionKind.any;
+}
+
+export function isArrayRunType(rt: RunType): rt is ArrayRunType {
+    return rt.src.kind === ReflectionKind.array;
+}
+
+export function isBigIntRunType(rt: RunType): rt is BigIntRunType {
+    return rt.src.kind === ReflectionKind.bigint;
+}
+
+export function isBooleanRunType(rt: RunType): rt is BooleanRunType {
+    return rt.src.kind === ReflectionKind.boolean;
+}
+
+export function isCallSignatureRunType(rt: RunType): rt is CallSignatureRunType {
+    return rt.src.kind === ReflectionKind.callSignature;
+}
+
+export function isDateRunType(rt: RunType): rt is DateRunType {
+    return rt.getTypeID() === ReflectionSubKind.date;
+}
+
+export function isEnumRunType(rt: RunType): rt is EnumRunType {
+    return rt.src.kind === ReflectionKind.enum;
+}
+
+export function isEnumMemberRunType(rt: RunType): rt is EnumMemberRunType {
+    return rt.src.kind === ReflectionKind.enumMember;
+}
+
+export function isFunctionRunType(rt: RunType): rt is FunctionRunType<any> {
+    return rt.src.kind === ReflectionKind.function;
+}
+
+export function isFunctionParamsRunType(rt: RunType): rt is FunctionParamsRunType {
+    return rt.src.subKind === ReflectionSubKind.params;
+}
+
+export function isAnyFunctionRunType(rt: RunType): rt is FunctionRunType<any> {
+    return (rt.src as any).return?.kind !== undefined;
+}
+
+export function isIndexSignatureRunType(rt: RunType): rt is IndexSignatureRunType {
+    return rt.src.kind === ReflectionKind.indexSignature;
+}
+
+export function isLiteralRunType(rt: RunType): rt is LiteralRunType {
+    return rt.src.kind === ReflectionKind.literal;
+}
+
+export function isMethodSignatureRunType(rt: RunType): rt is MethodSignatureRunType {
+    return rt.src.kind === ReflectionKind.methodSignature;
+}
+
+export function isNullRunType(rt: RunType): rt is NullRunType {
+    return rt.src.kind === ReflectionKind.null;
+}
+
+export function isNumberRunType(rt: RunType): rt is NumberRunType {
+    return rt.src.kind === ReflectionKind.number;
+}
+
+export function isInterfaceRunType(rt: RunType): rt is InterfaceRunType {
+    return rt.src.kind === ReflectionKind.objectLiteral;
+}
+
+export function isObjectLiteralRunType(rt: RunType): rt is InterfaceRunType {
+    return rt.src.kind === ReflectionKind.objectLiteral;
+}
+
+export function isClassRunType(rt: RunType, cls?: string | AnyClass): rt is ClassRunType {
+    const isClassRt = rt.src.kind === ReflectionKind.class && rt.src.subKind !== ReflectionSubKind.date;
+    if (!cls) return isClassRt;
+    return isClassRt && (rt.src.classType === cls || rt.src.classType.name === cls);
+}
+
+export function isIntersectionRunType(rt: RunType): rt is IntersectionRunType {
+    return rt.src.kind === ReflectionKind.intersection;
+}
+
+export function isPropertyRunType(rt: RunType): rt is PropertyRunType {
+    return rt.src.kind === ReflectionKind.property;
+}
+
+export function isPropertySignatureRunType(rt: RunType): rt is PropertyRunType {
+    return rt.src.kind === ReflectionKind.propertySignature;
+}
+
+export function isRegexpRunType(rt: RunType): rt is RegexpRunType {
+    return rt.src.kind === ReflectionKind.regexp;
+}
+
+export function isStringRunType(rt: RunType): rt is StringRunType {
+    return rt.src.kind === ReflectionKind.string;
+}
+
+export function isSymbolRunType(rt: RunType): rt is SymbolRunType {
+    return rt.src.kind === ReflectionKind.symbol;
+}
+
+export function isTupleRunType(rt: RunType): rt is TupleRunType {
+    return rt.src.kind === ReflectionKind.tuple;
+}
+
+export function isTupleMemberRunType(rt: RunType): rt is TupleMemberRunType {
+    return rt.src.kind === ReflectionKind.tupleMember;
+}
+
+export function isUndefinedRunType(rt: RunType): rt is UndefinedRunType {
+    return rt.src.kind === ReflectionKind.undefined;
+}
+
+export function isUnionRunType(rt: RunType): rt is UnionRunType {
+    return rt.src.kind === ReflectionKind.union;
+}
+
+export function isUnknownRunType(rt: RunType): rt is UnknownRunType {
+    return rt.src.kind === ReflectionKind.unknown;
+}
+
+export function isVoidRunType(rt: RunType): rt is VoidRunType {
+    return rt.src.kind === ReflectionKind.void;
+}
+
+export function isNeverRunType(rt: RunType): rt is NeverRunType {
+    return rt.src.kind === ReflectionKind.never;
+}
+
+export function isObjectRunType(rt: RunType): rt is ObjectRunType {
+    return rt.src.kind === ReflectionKind.object;
+}
+
+export function isParameterRunType(rt: RunType): rt is ParameterRunType {
+    return rt.src.kind === ReflectionKind.parameter;
+}
+
+export function isPromiseRunType(rt: RunType): rt is PromiseRunType {
+    return rt.src.kind === ReflectionKind.promise;
+}
+
+export function isConstructor(rt: InterfaceMember): rt is MethodSignatureRunType | MethodRunType {
+    return (
+        (rt.src.kind === ReflectionKind.method || rt.src.kind === ReflectionKind.methodSignature) &&
+        (rt.src as TypeMethod).name === 'constructor'
+    );
+}
+
+export function isChildAccessorType(rt: RunType): rt is RunTypeChildAccessor {
+    return !!(rt as any as RunTypeChildAccessor).getChildVarName && !!(rt as any as RunTypeChildAccessor).getChildLiteral;
+}
+
+export function isAtomicRunType(rt: RunType): rt is AtomicRunType<any> {
+    return rt.getFamily() === 'A';
+}
+
+export function isCollectionRunType(rt: RunType): rt is CollectionRunType<any> {
+    return rt.getFamily() === 'C';
+}
+
+export function isMemberRunType(rt: RunType): rt is MemberRunType<any> {
+    return rt.getFamily() === 'M';
+}
+
+export function isRunType(value: any): value is RunType {
+    return typeof value?.src?.kind === 'number' && typeof value?.getTypeID === 'function';
+}
+
+export function isJitErrorsCompiler(value: BaseFnCompiler): value is JitErrorsFnCompiler {
+    return value.fnID === JitFunctions.typeErrors.id || value.fnID === JitFunctions.unknownKeyErrors.id;
+}
+
+export function isNonSerializableClass(src: TypeClass): boolean {
+    return nonSerializableClasses.includes(src.classType);
+}
+
+export function isNonSerializableObject(src: TypeObjectLiteral): boolean {
+    if (!src.typeName) return false;
+    return nonSerializableGlobals.includes(src.typeName);
+}
+
+export function isNativeUtilityStringTypes(src: Type): boolean {
+    if (!src.typeName) return false;
+    return nativeUtilityStringTypes.includes(src.typeName);
+}
+
+export function hasType(src: any): src is {type: Type} {
+    return isType(src?.type);
+}
+
+export function hasTypes(src: any): src is {types: Type[]} {
+    return Array.isArray(src?.types) && isType(src);
+}
+
+export function hasReturn(src: any): src is {return: Type} {
+    return isType(src?.return);
+}
+
+export function hasParameters(src: any): src is {parameters: Type[]} {
+    return Array.isArray(src?.parameters) && isType(src);
+}
+
+export function hasIndexType(src: any): src is {indexType: Type} {
+    return isType(src?.indexType);
+}
+
+export function hasArguments(src: any): src is {arguments: Type[]} {
+    return Array.isArray(src?.arguments) && isType(src);
+}
+
+export function hasExtends(src: any): src is {extends: Type[]} {
+    return Array.isArray(src?.extends) && isType(src);
+}
+
+export function hasExtendsArguments(src: any): src is {extendsArguments: Type[]} {
+    return Array.isArray(src?.extendsArguments) && isType(src);
+}
+
+export function hasTypeArguments(src: any): src is {typeArguments: Type[]} {
+    return Array.isArray(src?.typeArguments) && isType(src);
+}
+
+export function hasTypeParameters(src: any): src is {typeParameters: TypeParameter[]} {
+    return Array.isArray(src?.typeParameters) && isType(src);
+}
+
+export function hasMembers(src: any): src is {members: InterfaceMember[]} {
+    return Array.isArray(src?.members) && isType(src);
+}
+
+export function hasImplements(src: any): src is {implements: Type[]} {
+    return Array.isArray(src?.implements) && isType(src);
+}
+
+export function isFormatParamMeta(src: TypeFormatValue): src is FormatParamMeta {
+    return (src as FormatParamMeta)?.val !== undefined;
+}