@mionjs/run-types 0.8.8 → 0.13.0

package/src/lib/createJitFunction.ts

@@ -1,87 +0,0 @@
-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

@@ -1,47 +0,0 @@
-/* ########
- * 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

@@ -1,144 +0,0 @@
-/* ########
- * 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

@@ -1,290 +0,0 @@
-/* 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;
-}