@mionjs/run-types 0.8.0-alpha.0

package/.dist/cjs/src/lib/formats.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"formats.cjs","sources":["../../../../src/lib/formats.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 {CompiledPureFunction, TypeFormatParams, TypeFormatValue} from '@mionjs/core';\nimport {ReflectionKindName} from '../constants.kind.ts';\nimport type {FormatAnnotation} from '../types.ts';\nimport {typeAnnotation, ReflectionKind} from '@deepkit/type';\nimport type {BaseRunType} from './baseRunTypes.ts';\nimport type {JitErrorsFnCompiler, JitFnCompiler} from './jitFnCompiler.ts';\nimport type {BaseRunTypeFormat} from './baseRunTypeFormat.ts';\nimport {toLiteralInContext} from './utils.ts';\n\n// ################# REGISTER FORMATTERS & PURE FUNCTIONS  #################\n\nconst typeAnnotationsCache = new Map<string, BaseRunTypeFormat>();\nconst formatterPrefix = 'f';\n\n/** Adds a TypeFormatter or TypeValidator to the formatters cache */\nexport function registerFormatter<T extends BaseRunTypeFormat>(operation: T, shouldThrow = false): T {\n    const id = getFormatterKey(formatterPrefix, operation.kind, operation.name);\n    const exiting = typeAnnotationsCache.get(id);\n    if (exiting && exiting !== operation) {\n        if (shouldThrow)\n            throw new Error(`Annotation type ${operation.name} already registered for ${ReflectionKindName[operation.kind]}`);\n        return operation;\n    }\n    typeAnnotationsCache.set(id, operation);\n    return operation;\n}\n\n/** Gets a TypeFormatter or TypeValidator to the formatters cache */\nexport function getFormatterFromCache(\n    typeKind: ReflectionKind,\n    name: string,\n    shouldThrow = false\n): BaseRunTypeFormat | undefined {\n    const formatter = typeAnnotationsCache.get(getFormatterKey(formatterPrefix, typeKind, name));\n    if (!formatter) {\n        if (shouldThrow) throw new Error(`Annotation type ${name} not found for ${ReflectionKindName[typeKind]}`);\n        return undefined;\n    }\n    return formatter;\n}\n\nexport function getFormatterKey(prefix: string, kind: string | number, name: string | number): string {\n    return `${prefix}:${kind}:${name}`;\n}\n\n/** Returns the validator for a given type. ATM only one validator is allowed for each type */\nexport function getRunTypeFormat(rt: BaseRunType): BaseRunTypeFormat | undefined {\n    return getFormatAnnotation(rt)?.formatter;\n}\n\nexport function getRunTypeTransformer(rt: BaseRunType): BaseRunTypeFormat | undefined {\n    const rtFormat = getRunTypeFormat(rt);\n    if (rtFormat?.emitFormat) return rtFormat;\n    return undefined;\n}\n\n// ################# ANNOTATIONS  #################\n\n/**\n * Reads deepkit annotations and augment them with the associated formatters.\n * @param rt\n * @returns\n */\nexport function initFormatAnnotations(rt: BaseRunType): FormatAnnotation | undefined {\n    const annotations = typeAnnotation.getAnnotations(rt.src);\n    if (annotations.length === 0) return;\n    if (annotations.length > 1)\n        throw new Error(`Only one type annotation is allowed for runTypes and ${rt.getTypeName()} has ${annotations.length}`);\n    const annotation = annotations[0] as FormatAnnotation;\n    if (!annotation.name) throw new Error(`Type annotation must have a name for ${rt.getTypeName()}`);\n    const params = annotation.options;\n    const formatter = getFormatterFromCache(rt.src.kind, annotation.name);\n    // formatter property is only added to registered formatters, this allows using other type annotations that are not formatters\n    if (formatter && params.kind === ReflectionKind.objectLiteral) {\n        annotation.formatter = formatter;\n        return annotation;\n    }\n    return annotation as FormatAnnotation;\n}\n\n/** Returns the params for a given type formatter */\nexport function getFormatterParams<P extends TypeFormatParams>(rt: BaseRunType, fmtName: string): P {\n    const annotation = getFormatAnnotation(rt);\n    if (annotation?.name === fmtName) {\n        if (annotation.params) return annotation.params as P;\n        annotation.params = typeAnnotation.getOption(rt.src, annotation.name) as P;\n        return annotation.params as P;\n    }\n    throw new Error(`Type Formatter ${fmtName} not found for ${rt.getTypeName()}`);\n}\n\nexport function getFormatAnnotation(rt: BaseRunType): FormatAnnotation | undefined {\n    const parsedAnnotations = typeAnnotation.getAnnotations(rt.src);\n    const formatAnnotations = parsedAnnotations.filter((a) => (a as FormatAnnotation).formatter);\n    return formatAnnotations[0] as FormatAnnotation | undefined;\n}\n\n// ################# COMPILING  #################\n\n// TODO, read ignoreProps from multiple formatters, rather than a constant here\nexport const defaultIgnoreFormatProps = ['mockSamples'];\n\n/**\n * Transforms a params object into a literal string to be used in JIT code.\n * ie: {total: 5, name: 'hello'} gets transformed into teh string '{total: 5, name: \"hello\"}' that can be used as JIT code.\n * Some literals are automatically added to the context to reduce code size. in this case the reference to the context variable is returned.\n *\n * @param comp\n * @param params\n * @param ignoreProps\n * @returns\n */\nexport function paramsToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue, ignoreProps?: string[]) {\n    return toLiteralInContext(comp, params, ignoreProps, false);\n}\n\nexport function getToLiteralFn(comp: JitFnCompiler | JitErrorsFnCompiler, ignoreProps?: string[]) {\n    return (params: TypeFormatValue) => paramsToLiteral(comp, params, ignoreProps);\n}\n\n/**\n * Transforms a dependencies object into a string literal that can be used as JIT code.\n * Dependencies object can contain pure functions or code.\n * Pure functions will be load as dependency using jitUtils.getPureFn, and code will be left as is.\n * ie: {helloFn: function hello(){}, code: 'v + 2'} gets transformed into the string '{helloFn: utl.getPureFn(\"hello\"), code: v + 2}'\n * @param comp\n * @param params\n * @param ignoreProps\n * @returns\n */\nexport function dependenciesToLiteral(\n    comp: JitFnCompiler | JitErrorsFnCompiler,\n    params: Record<string, string | CompiledPureFunction>,\n    ignoreProps: string[] = []\n) {\n    return toLiteralInContext(comp, params, ignoreProps, true);\n}\n"],"names":["ReflectionKindName","typeAnnotation","ReflectionKind","toLiteralInContext"],"mappings":";;;;;AAkBA,MAAM,2CAA2B,IAAA;AACjC,MAAM,kBAAkB;AAGjB,SAAS,kBAA+C,WAAc,cAAc,OAAU;AACjG,QAAM,KAAK,gBAAgB,iBAAiB,UAAU,MAAM,UAAU,IAAI;AAC1E,QAAM,UAAU,qBAAqB,IAAI,EAAE;AAC3C,MAAI,WAAW,YAAY,WAAW;AAClC,QAAI;AACA,YAAM,IAAI,MAAM,mBAAmB,UAAU,IAAI,2BAA2BA,sCAAmB,UAAU,IAAI,CAAC,EAAE;AACpH,WAAO;AAAA,EACX;AACA,uBAAqB,IAAI,IAAI,SAAS;AACtC,SAAO;AACX;AAGO,SAAS,sBACZ,UACA,MACA,cAAc,OACe;AAC7B,QAAM,YAAY,qBAAqB,IAAI,gBAAgB,iBAAiB,UAAU,IAAI,CAAC;AAC3F,MAAI,CAAC,WAAW;AACZ,QAAI,YAAa,OAAM,IAAI,MAAM,mBAAmB,IAAI,kBAAkBA,mBAAAA,mBAAmB,QAAQ,CAAC,EAAE;AACxG,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAEO,SAAS,gBAAgB,QAAgB,MAAuB,MAA+B;AAClG,SAAO,GAAG,MAAM,IAAI,IAAI,IAAI,IAAI;AACpC;AAGO,SAAS,iBAAiB,IAAgD;AAC7E,SAAO,oBAAoB,EAAE,GAAG;AACpC;AAEO,SAAS,sBAAsB,IAAgD;AAClF,QAAM,WAAW,iBAAiB,EAAE;AACpC,MAAI,UAAU,WAAY,QAAO;AACjC,SAAO;AACX;AASO,SAAS,sBAAsB,IAA+C;AACjF,QAAM,cAAcC,KAAAA,eAAe,eAAe,GAAG,GAAG;AACxD,MAAI,YAAY,WAAW,EAAG;AAC9B,MAAI,YAAY,SAAS;AACrB,UAAM,IAAI,MAAM,wDAAwD,GAAG,aAAa,QAAQ,YAAY,MAAM,EAAE;AACxH,QAAM,aAAa,YAAY,CAAC;AAChC,MAAI,CAAC,WAAW,KAAM,OAAM,IAAI,MAAM,wCAAwC,GAAG,YAAA,CAAa,EAAE;AAChG,QAAM,SAAS,WAAW;AAC1B,QAAM,YAAY,sBAAsB,GAAG,IAAI,MAAM,WAAW,IAAI;AAEpE,MAAI,aAAa,OAAO,SAASC,KAAAA,eAAe,eAAe;AAC3D,eAAW,YAAY;AACvB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AAGO,SAAS,mBAA+C,IAAiB,SAAoB;AAChG,QAAM,aAAa,oBAAoB,EAAE;AACzC,MAAI,YAAY,SAAS,SAAS;AAC9B,QAAI,WAAW,OAAQ,QAAO,WAAW;AACzC,eAAW,SAASD,oBAAe,UAAU,GAAG,KAAK,WAAW,IAAI;AACpE,WAAO,WAAW;AAAA,EACtB;AACA,QAAM,IAAI,MAAM,kBAAkB,OAAO,kBAAkB,GAAG,YAAA,CAAa,EAAE;AACjF;AAEO,SAAS,oBAAoB,IAA+C;AAC/E,QAAM,oBAAoBA,KAAAA,eAAe,eAAe,GAAG,GAAG;AAC9D,QAAM,oBAAoB,kBAAkB,OAAO,CAAC,MAAO,EAAuB,SAAS;AAC3F,SAAO,kBAAkB,CAAC;AAC9B;AAKO,MAAM,2BAA2B,CAAC,aAAa;AAY/C,SAAS,gBAAgB,MAA2C,QAAyB,aAAwB;AACxH,SAAOE,cAAAA,mBAAmB,MAAM,QAAQ,aAAa,KAAK;AAC9D;AAEO,SAAS,eAAe,MAA2C,aAAwB;AAC9F,SAAO,CAAC,WAA4B,gBAAgB,MAAM,QAAQ,WAAW;AACjF;AAYO,SAAS,sBACZ,MACA,QACA,cAAwB,CAAA,GAC1B;AACE,SAAOA,cAAAA,mBAAmB,MAAM,QAAQ,aAAa,IAAI;AAC7D;;;;;;;;;;;;;"}

package/.dist/cjs/src/lib/formats.d.ts

@@ -0,0 +1,18 @@
+import { CompiledPureFunction, TypeFormatParams, TypeFormatValue } from '@mionjs/core';
+import { FormatAnnotation } from '../types.ts';
+import { ReflectionKind } from '@deepkit/type';
+import { BaseRunType } from './baseRunTypes.ts';
+import { JitErrorsFnCompiler, JitFnCompiler } from './jitFnCompiler.ts';
+import { BaseRunTypeFormat } from './baseRunTypeFormat.ts';
+export declare function registerFormatter<T extends BaseRunTypeFormat>(operation: T, shouldThrow?: boolean): T;
+export declare function getFormatterFromCache(typeKind: ReflectionKind, name: string, shouldThrow?: boolean): BaseRunTypeFormat | undefined;
+export declare function getFormatterKey(prefix: string, kind: string | number, name: string | number): string;
+export declare function getRunTypeFormat(rt: BaseRunType): BaseRunTypeFormat | undefined;
+export declare function getRunTypeTransformer(rt: BaseRunType): BaseRunTypeFormat | undefined;
+export declare function initFormatAnnotations(rt: BaseRunType): FormatAnnotation | undefined;
+export declare function getFormatterParams<P extends TypeFormatParams>(rt: BaseRunType, fmtName: string): P;
+export declare function getFormatAnnotation(rt: BaseRunType): FormatAnnotation | undefined;
+export declare const defaultIgnoreFormatProps: string[];
+export declare function paramsToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: TypeFormatValue, ignoreProps?: string[]): string;
+export declare function getToLiteralFn(comp: JitFnCompiler | JitErrorsFnCompiler, ignoreProps?: string[]): (params: TypeFormatValue) => string;
+export declare function dependenciesToLiteral(comp: JitFnCompiler | JitErrorsFnCompiler, params: Record<string, string | CompiledPureFunction>, ignoreProps?: string[]): string;

package/.dist/cjs/src/lib/guards.cjs

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const src_constants_kind = require("../constants.kind.cjs");
+const src_constants = require("../constants.cjs");
+const src_constants_functions = require("../constants.functions.cjs");
+function isAnyRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.any;
+}
+function isArrayRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.array;
+}
+function isBigIntRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.bigint;
+}
+function isBooleanRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.boolean;
+}
+function isCallSignatureRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.callSignature;
+}
+function isDateRunType(rt) {
+  return rt.getTypeID() === src_constants_kind.ReflectionSubKind.date;
+}
+function isEnumRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.enum;
+}
+function isEnumMemberRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.enumMember;
+}
+function isFunctionRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.function;
+}
+function isFunctionParamsRunType(rt) {
+  return rt.src.subKind === src_constants_kind.ReflectionSubKind.params;
+}
+function isAnyFunctionRunType(rt) {
+  return rt.src.return?.kind !== void 0;
+}
+function isIndexSignatureRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.indexSignature;
+}
+function isLiteralRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.literal;
+}
+function isMethodSignatureRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.methodSignature;
+}
+function isNullRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.null;
+}
+function isNumberRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.number;
+}
+function isInterfaceRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.objectLiteral;
+}
+function isObjectLiteralRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.objectLiteral;
+}
+function isClassRunType(rt, cls) {
+  const isClassRt = rt.src.kind === type.ReflectionKind.class && rt.src.subKind !== src_constants_kind.ReflectionSubKind.date;
+  if (!cls) return isClassRt;
+  return isClassRt && (rt.src.classType === cls || rt.src.classType.name === cls);
+}
+function isIntersectionRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.intersection;
+}
+function isPropertyRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.property;
+}
+function isPropertySignatureRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.propertySignature;
+}
+function isRegexpRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.regexp;
+}
+function isStringRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.string;
+}
+function isSymbolRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.symbol;
+}
+function isTupleRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.tuple;
+}
+function isTupleMemberRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.tupleMember;
+}
+function isUndefinedRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.undefined;
+}
+function isUnionRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.union;
+}
+function isUnknownRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.unknown;
+}
+function isVoidRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.void;
+}
+function isNeverRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.never;
+}
+function isObjectRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.object;
+}
+function isParameterRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.parameter;
+}
+function isPromiseRunType(rt) {
+  return rt.src.kind === type.ReflectionKind.promise;
+}
+function isConstructor(rt) {
+  return (rt.src.kind === type.ReflectionKind.method || rt.src.kind === type.ReflectionKind.methodSignature) && rt.src.name === "constructor";
+}
+function isChildAccessorType(rt) {
+  return !!rt.getChildVarName && !!rt.getChildLiteral;
+}
+function isAtomicRunType(rt) {
+  return rt.getFamily() === "A";
+}
+function isCollectionRunType(rt) {
+  return rt.getFamily() === "C";
+}
+function isMemberRunType(rt) {
+  return rt.getFamily() === "M";
+}
+function isRunType(value) {
+  return typeof value?.src?.kind === "number" && typeof value?.getTypeID === "function";
+}
+function isJitErrorsCompiler(value) {
+  return value.fnID === src_constants_functions.JitFunctions.typeErrors.id || value.fnID === src_constants_functions.JitFunctions.unknownKeyErrors.id;
+}
+function isNonSerializableClass(src) {
+  return src_constants.nonSerializableClasses.includes(src.classType);
+}
+function isNonSerializableObject(src) {
+  if (!src.typeName) return false;
+  return src_constants.nonSerializableGlobals.includes(src.typeName);
+}
+function isNativeUtilityStringTypes(src) {
+  if (!src.typeName) return false;
+  return src_constants.nativeUtilityStringTypes.includes(src.typeName);
+}
+function hasType(src) {
+  return type.isType(src?.type);
+}
+function hasTypes(src) {
+  return Array.isArray(src?.types) && type.isType(src);
+}
+function hasReturn(src) {
+  return type.isType(src?.return);
+}
+function hasParameters(src) {
+  return Array.isArray(src?.parameters) && type.isType(src);
+}
+function hasIndexType(src) {
+  return type.isType(src?.indexType);
+}
+function hasArguments(src) {
+  return Array.isArray(src?.arguments) && type.isType(src);
+}
+function hasExtends(src) {
+  return Array.isArray(src?.extends) && type.isType(src);
+}
+function hasExtendsArguments(src) {
+  return Array.isArray(src?.extendsArguments) && type.isType(src);
+}
+function hasTypeArguments(src) {
+  return Array.isArray(src?.typeArguments) && type.isType(src);
+}
+function hasTypeParameters(src) {
+  return Array.isArray(src?.typeParameters) && type.isType(src);
+}
+function hasMembers(src) {
+  return Array.isArray(src?.members) && type.isType(src);
+}
+function hasImplements(src) {
+  return Array.isArray(src?.implements) && type.isType(src);
+}
+function isFormatParamMeta(src) {
+  return src?.val !== void 0;
+}
+exports.hasArguments = hasArguments;
+exports.hasExtends = hasExtends;
+exports.hasExtendsArguments = hasExtendsArguments;
+exports.hasImplements = hasImplements;
+exports.hasIndexType = hasIndexType;
+exports.hasMembers = hasMembers;
+exports.hasParameters = hasParameters;
+exports.hasReturn = hasReturn;
+exports.hasType = hasType;
+exports.hasTypeArguments = hasTypeArguments;
+exports.hasTypeParameters = hasTypeParameters;
+exports.hasTypes = hasTypes;
+exports.isAnyFunctionRunType = isAnyFunctionRunType;
+exports.isAnyRunType = isAnyRunType;
+exports.isArrayRunType = isArrayRunType;
+exports.isAtomicRunType = isAtomicRunType;
+exports.isBigIntRunType = isBigIntRunType;
+exports.isBooleanRunType = isBooleanRunType;
+exports.isCallSignatureRunType = isCallSignatureRunType;
+exports.isChildAccessorType = isChildAccessorType;
+exports.isClassRunType = isClassRunType;
+exports.isCollectionRunType = isCollectionRunType;
+exports.isConstructor = isConstructor;
+exports.isDateRunType = isDateRunType;
+exports.isEnumMemberRunType = isEnumMemberRunType;
+exports.isEnumRunType = isEnumRunType;
+exports.isFormatParamMeta = isFormatParamMeta;
+exports.isFunctionParamsRunType = isFunctionParamsRunType;
+exports.isFunctionRunType = isFunctionRunType;
+exports.isIndexSignatureRunType = isIndexSignatureRunType;
+exports.isInterfaceRunType = isInterfaceRunType;
+exports.isIntersectionRunType = isIntersectionRunType;
+exports.isJitErrorsCompiler = isJitErrorsCompiler;
+exports.isLiteralRunType = isLiteralRunType;
+exports.isMemberRunType = isMemberRunType;
+exports.isMethodSignatureRunType = isMethodSignatureRunType;
+exports.isNativeUtilityStringTypes = isNativeUtilityStringTypes;
+exports.isNeverRunType = isNeverRunType;
+exports.isNonSerializableClass = isNonSerializableClass;
+exports.isNonSerializableObject = isNonSerializableObject;
+exports.isNullRunType = isNullRunType;
+exports.isNumberRunType = isNumberRunType;
+exports.isObjectLiteralRunType = isObjectLiteralRunType;
+exports.isObjectRunType = isObjectRunType;
+exports.isParameterRunType = isParameterRunType;
+exports.isPromiseRunType = isPromiseRunType;
+exports.isPropertyRunType = isPropertyRunType;
+exports.isPropertySignatureRunType = isPropertySignatureRunType;
+exports.isRegexpRunType = isRegexpRunType;
+exports.isRunType = isRunType;
+exports.isStringRunType = isStringRunType;
+exports.isSymbolRunType = isSymbolRunType;
+exports.isTupleMemberRunType = isTupleMemberRunType;
+exports.isTupleRunType = isTupleRunType;
+exports.isUndefinedRunType = isUndefinedRunType;
+exports.isUnionRunType = isUnionRunType;
+exports.isUnknownRunType = isUnknownRunType;
+exports.isVoidRunType = isVoidRunType;
+//# sourceMappingURL=guards.cjs.map

package/.dist/cjs/src/lib/guards.cjs.map

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

package/.dist/cjs/src/lib/guards.d.ts

@@ -0,0 +1,120 @@
+import { Type, TypeClass, TypeObjectLiteral, TypeParameter } from '@deepkit/type';
+import { AnyClass, FormatParamMeta, TypeFormatValue } from '@mionjs/core';
+import { RunType, RunTypeChildAccessor } from '../types.ts';
+import { StringRunType } from '../nodes/atomic/string.ts';
+import { DateRunType } from '../nodes/atomic/date.ts';
+import { NumberRunType } from '../nodes/atomic/number.ts';
+import { BooleanRunType } from '../nodes/atomic/boolean.ts';
+import { NullRunType } from '../nodes/atomic/null.ts';
+import { BigIntRunType } from '../nodes/atomic/bigInt.ts';
+import { AnyRunType } from '../nodes/atomic/any.ts';
+import { UndefinedRunType } from '../nodes/atomic/undefined.ts';
+import { UnknownRunType } from '../nodes/atomic/unknown.ts';
+import { VoidRunType } from '../nodes/atomic/void.ts';
+import { ArrayRunType } from '../nodes/member/array.ts';
+import { LiteralRunType } from '../nodes/atomic/literal.ts';
+import { RegexpRunType } from '../nodes/atomic/regexp.ts';
+import { NeverRunType } from '../nodes/atomic/never.ts';
+import { EnumRunType } from '../nodes/atomic/enum.ts';
+import { EnumMemberRunType } from '../nodes/atomic/enumMember.ts';
+import { UnionRunType } from '../nodes/collection/union.ts';
+import { TupleRunType } from '../nodes/collection/tuple.ts';
+import { TupleMemberRunType } from '../nodes/member/tupleMember.ts';
+import { InterfaceRunType, InterfaceMember } from '../nodes/collection/interface.ts';
+import { PropertyRunType } from '../nodes/member/property.ts';
+import { IndexSignatureRunType } from '../nodes/member/indexProperty.ts';
+import { MethodSignatureRunType } from '../nodes/member/methodSignature.ts';
+import { CallSignatureRunType } from '../nodes/member/callSignature.ts';
+import { FunctionRunType } from '../nodes/function/function.ts';
+import { FunctionParamsRunType } from '../nodes/collection/functionParams.ts';
+import { ParameterRunType } from '../nodes/member/param.ts';
+import { PromiseRunType } from '../nodes/native/promise.ts';
+import { ObjectRunType } from '../nodes/atomic/object.ts';
+import { MethodRunType } from '../nodes/member/method.ts';
+import { AtomicRunType, CollectionRunType, MemberRunType } from './baseRunTypes.ts';
+import { BaseFnCompiler, JitErrorsFnCompiler } from './jitFnCompiler.ts';
+import { ClassRunType } from '../nodes/collection/class.ts';
+import { IntersectionRunType } from '../nodes/collection/intersection.ts';
+import { SymbolRunType } from '../nodes/atomic/symbol.ts';
+export declare function isAnyRunType(rt: RunType): rt is AnyRunType;
+export declare function isArrayRunType(rt: RunType): rt is ArrayRunType;
+export declare function isBigIntRunType(rt: RunType): rt is BigIntRunType;
+export declare function isBooleanRunType(rt: RunType): rt is BooleanRunType;
+export declare function isCallSignatureRunType(rt: RunType): rt is CallSignatureRunType;
+export declare function isDateRunType(rt: RunType): rt is DateRunType;
+export declare function isEnumRunType(rt: RunType): rt is EnumRunType;
+export declare function isEnumMemberRunType(rt: RunType): rt is EnumMemberRunType;
+export declare function isFunctionRunType(rt: RunType): rt is FunctionRunType<any>;
+export declare function isFunctionParamsRunType(rt: RunType): rt is FunctionParamsRunType;
+export declare function isAnyFunctionRunType(rt: RunType): rt is FunctionRunType<any>;
+export declare function isIndexSignatureRunType(rt: RunType): rt is IndexSignatureRunType;
+export declare function isLiteralRunType(rt: RunType): rt is LiteralRunType;
+export declare function isMethodSignatureRunType(rt: RunType): rt is MethodSignatureRunType;
+export declare function isNullRunType(rt: RunType): rt is NullRunType;
+export declare function isNumberRunType(rt: RunType): rt is NumberRunType;
+export declare function isInterfaceRunType(rt: RunType): rt is InterfaceRunType;
+export declare function isObjectLiteralRunType(rt: RunType): rt is InterfaceRunType;
+export declare function isClassRunType(rt: RunType, cls?: string | AnyClass): rt is ClassRunType;
+export declare function isIntersectionRunType(rt: RunType): rt is IntersectionRunType;
+export declare function isPropertyRunType(rt: RunType): rt is PropertyRunType;
+export declare function isPropertySignatureRunType(rt: RunType): rt is PropertyRunType;
+export declare function isRegexpRunType(rt: RunType): rt is RegexpRunType;
+export declare function isStringRunType(rt: RunType): rt is StringRunType;
+export declare function isSymbolRunType(rt: RunType): rt is SymbolRunType;
+export declare function isTupleRunType(rt: RunType): rt is TupleRunType;
+export declare function isTupleMemberRunType(rt: RunType): rt is TupleMemberRunType;
+export declare function isUndefinedRunType(rt: RunType): rt is UndefinedRunType;
+export declare function isUnionRunType(rt: RunType): rt is UnionRunType;
+export declare function isUnknownRunType(rt: RunType): rt is UnknownRunType;
+export declare function isVoidRunType(rt: RunType): rt is VoidRunType;
+export declare function isNeverRunType(rt: RunType): rt is NeverRunType;
+export declare function isObjectRunType(rt: RunType): rt is ObjectRunType;
+export declare function isParameterRunType(rt: RunType): rt is ParameterRunType;
+export declare function isPromiseRunType(rt: RunType): rt is PromiseRunType;
+export declare function isConstructor(rt: InterfaceMember): rt is MethodSignatureRunType | MethodRunType;
+export declare function isChildAccessorType(rt: RunType): rt is RunTypeChildAccessor;
+export declare function isAtomicRunType(rt: RunType): rt is AtomicRunType<any>;
+export declare function isCollectionRunType(rt: RunType): rt is CollectionRunType<any>;
+export declare function isMemberRunType(rt: RunType): rt is MemberRunType<any>;
+export declare function isRunType(value: any): value is RunType;
+export declare function isJitErrorsCompiler(value: BaseFnCompiler): value is JitErrorsFnCompiler;
+export declare function isNonSerializableClass(src: TypeClass): boolean;
+export declare function isNonSerializableObject(src: TypeObjectLiteral): boolean;
+export declare function isNativeUtilityStringTypes(src: Type): boolean;
+export declare function hasType(src: any): src is {
+    type: Type;
+};
+export declare function hasTypes(src: any): src is {
+    types: Type[];
+};
+export declare function hasReturn(src: any): src is {
+    return: Type;
+};
+export declare function hasParameters(src: any): src is {
+    parameters: Type[];
+};
+export declare function hasIndexType(src: any): src is {
+    indexType: Type;
+};
+export declare function hasArguments(src: any): src is {
+    arguments: Type[];
+};
+export declare function hasExtends(src: any): src is {
+    extends: Type[];
+};
+export declare function hasExtendsArguments(src: any): src is {
+    extendsArguments: Type[];
+};
+export declare function hasTypeArguments(src: any): src is {
+    typeArguments: Type[];
+};
+export declare function hasTypeParameters(src: any): src is {
+    typeParameters: TypeParameter[];
+};
+export declare function hasMembers(src: any): src is {
+    members: InterfaceMember[];
+};
+export declare function hasImplements(src: any): src is {
+    implements: Type[];
+};
+export declare function isFormatParamMeta(src: TypeFormatValue): src is FormatParamMeta;