@trapi/metadata 0.1.3 → 0.1.7

package/dist/resolver/type-node.js

@@ -28,33 +28,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeNodeResolver = void 0;
 const ts = __importStar(require("typescript"));
 const metadata_utils_1 = require("@trapi/metadata-utils");
+const decorator_1 = require("../decorator");
 const utils_1 = require("../utils");
 const error_1 = require("./error");
 const utils_2 = require("./utils");
-const decorator_1 = require("../decorator");
 const localReferenceTypeCache = {};
 const inProgressTypes = {};
 function getPropertyValidators(property) {
     return {};
 }
 class TypeNodeResolver {
-    typeNode;
-    current;
-    parentNode;
-    context;
-    referencer;
     constructor(typeNode, current, parentNode, context = {}, referencer) {
         this.typeNode = typeNode;
         this.current = current;
         this.parentNode = parentNode;
         this.context = context;
         this.referencer = referencer;
+        this.attemptToResolveKindToPrimitive = (syntaxKind) => {
+            if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
+                return 'number';
+            }
+            if (syntaxKind === ts.SyntaxKind.StringKeyword) {
+                return 'string';
+            }
+            if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
+                return 'boolean';
+            }
+            if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
+                return 'void';
+            }
+            return undefined;
+        };
     }
     static clearCache() {
-        Object.keys(localReferenceTypeCache).forEach(key => {
+        Object.keys(localReferenceTypeCache).forEach((key) => {
             delete localReferenceTypeCache[key];
         });
-        Object.keys(inProgressTypes).forEach(key => {
+        Object.keys(inProgressTypes).forEach((key) => {
             delete inProgressTypes[key];
         });
     }
@@ -76,18 +86,14 @@ class TypeNodeResolver {
             };
         }
         if (ts.isUnionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map(type => {
-                return new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve();
-            });
+            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
             return {
                 typeName: 'union',
                 members: types,
             };
         }
         if (ts.isIntersectionTypeNode(this.typeNode)) {
-            const types = this.typeNode.types.map(type => {
-                return new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve();
-            });
+            const types = this.typeNode.types.map((type) => new TypeNodeResolver(type, this.current, this.parentNode, this.context).resolve());
             return {
                 typeName: 'intersection',
                 members: types,
@@ -106,36 +112,36 @@ class TypeNodeResolver {
         }
         if (ts.isTypeLiteralNode(this.typeNode)) {
             const properties = this.typeNode.members
-                .filter(member => ts.isPropertySignature(member))
+                .filter((member) => ts.isPropertySignature(member))
                 .reduce((res, propertySignature) => {
                 const type = new TypeNodeResolver(propertySignature.type, this.current, propertySignature, this.context).resolve();
                 const property = {
-                    deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, tag => tag.tagName.text === 'deprecated'),
+                    deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, (tag) => tag.tagName.text === 'deprecated'),
                     example: TypeNodeResolver.getNodeExample(propertySignature),
                     default: (0, utils_1.getJSDocTagComment)(propertySignature, 'default'),
                     description: this.getNodeDescription(propertySignature),
                     format: TypeNodeResolver.getNodeFormat(propertySignature),
                     name: propertySignature.name.text,
                     required: !propertySignature.questionToken,
-                    type: type,
-                    validators: getPropertyValidators(propertySignature) || {}
+                    type,
+                    validators: getPropertyValidators(propertySignature) || {},
                 };
                 return [property, ...res];
             }, []);
-            const indexMember = this.typeNode.members.find(member => ts.isIndexSignatureDeclaration(member));
+            const indexMember = this.typeNode.members.find((member) => ts.isIndexSignatureDeclaration(member));
             let additionalType;
             if (indexMember) {
                 const indexSignatureDeclaration = indexMember;
                 const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
                 if (indexType.typeName !== 'string') {
-                    throw new error_1.ResolverError(`Only string indexes are supported.`, this.typeNode);
+                    throw new error_1.ResolverError('Only string indexes are supported.', this.typeNode);
                 }
                 additionalType = new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
             }
             return {
                 additionalProperties: indexMember && additionalType,
                 typeName: 'nestedObjectLiteral',
-                properties: properties,
+                properties,
             };
         }
         if (this.typeNode.kind === ts.SyntaxKind.ObjectKeyword || ts.isFunctionTypeNode(this.typeNode)) {
@@ -144,26 +150,26 @@ class TypeNodeResolver {
         if (ts.isMappedTypeNode(this.typeNode) && this.referencer) {
             const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer);
             const mappedTypeNode = this.typeNode;
-            const typeChecker = this.current.typeChecker;
+            const { typeChecker } = this.current;
             const getDeclaration = (prop) => prop.declarations && prop.declarations[0];
             const isIgnored = (prop) => {
                 const declaration = getDeclaration(prop);
-                return (prop.getJsDocTags().find(tag => tag.name === 'ignore') !== undefined ||
+                return (prop.getJsDocTags().find((tag) => tag.name === 'ignore') !== undefined ||
                     (declaration !== undefined && !ts.isPropertyDeclaration(declaration) && !ts.isPropertySignature(declaration) && !ts.isParameter(declaration)));
             };
             const properties = type
                 .getProperties()
                 // Ignore methods, getter, setter and @ignored props
-                .filter(property => isIgnored(property) === false)
+                .filter((property) => isIgnored(property) === false)
                 // Transform to property
-                .map(property => {
+                .map((property) => {
                 const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, this.typeNode);
                 const declaration = getDeclaration(property);
                 if (declaration && ts.isPropertySignature(declaration)) {
-                    return { ...this.propertyFromSignature(declaration, mappedTypeNode.questionToken), name: property.getName() };
+                    return Object.assign(Object.assign({}, this.propertyFromSignature(declaration, mappedTypeNode.questionToken)), { name: property.getName() });
                 }
-                else if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) {
-                    return { ...this.propertyFromDeclaration(declaration, mappedTypeNode.questionToken), name: property.getName() };
+                if (declaration && (ts.isPropertyDeclaration(declaration) || ts.isParameter(declaration))) {
+                    return Object.assign(Object.assign({}, this.propertyFromDeclaration(declaration, mappedTypeNode.questionToken)), { name: property.getName() });
                 }
                 // Resolve default value, required and typeNode
                 let required = false;
@@ -177,7 +183,7 @@ class TypeNodeResolver {
                 // Push property
                 return {
                     name: property.getName(),
-                    required: required,
+                    required,
                     deprecated: false,
                     type: new TypeNodeResolver(typeNode, this.current, this.typeNode, this.context, this.referencer).resolve(),
                     validators: {},
@@ -185,7 +191,7 @@ class TypeNodeResolver {
             });
             return {
                 typeName: 'nestedObjectLiteral',
-                properties: properties,
+                properties,
             };
         }
         if (ts.isConditionalTypeNode(this.typeNode) && this.referencer && ts.isTypeReferenceNode(this.referencer)) {
@@ -201,15 +207,13 @@ class TypeNodeResolver {
                         // Note: I don't understand why typescript lose type for `this.referencer` (from above with isTypeReferenceNode())
                         return this.getTypeAliasReference(declaration, this.current.typeChecker.typeToString(type), this.referencer);
                     }
-                    else if (ts.isEnumDeclaration(declaration)) {
+                    if (ts.isEnumDeclaration(declaration)) {
                         return this.getEnumerateType(declaration.name);
                     }
-                    else {
-                        throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
-                    }
+                    throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. We found an aliasSymbol and it's declaration was of kind ${declaration.kind}`, this.typeNode);
                 });
             }
-            else if (type.isClassOrInterface()) {
+            if (type.isClassOrInterface()) {
                 let declaration = type.symbol.declarations[0];
                 if (declaration.name) {
                     declaration = this.getModelTypeDeclaration(declaration.name);
@@ -217,13 +221,11 @@ class TypeNodeResolver {
                 const name = TypeNodeResolver.getRefTypeName(this.referencer.getText());
                 return this.handleCachingAndCircularReferences(name, () => this.getModelReference(declaration, this.current.typeChecker.typeToString(type)));
             }
-            else {
-                try {
-                    return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
-                }
-                catch {
-                    throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
-                }
+            try {
+                return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(type, undefined, ts.NodeBuilderFlags.NoTruncation), this.current, this.typeNode, this.context, this.referencer).resolve();
+            }
+            catch (_a) {
+                throw new error_1.ResolverError(`Couldn't resolve Conditional to TypeNode. If you think this should be resolvable, please file an Issue. The flags on the result of the ConditionalType was ${type.flags}`, this.typeNode);
             }
         }
         if (ts.isTypeOperatorNode(this.typeNode) && this.typeNode.operator === ts.SyntaxKind.KeyOfKeyword) {
@@ -260,22 +262,20 @@ class TypeNodeResolver {
             try {
                 return new TypeNodeResolver(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined), this.current, this.typeNode, this.context, this.referencer).resolve();
             }
-            catch {
+            catch (_b) {
                 throw new error_1.ResolverError(`Could not determine the keys on ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.current.typeChecker.typeToTypeNode(declaration, undefined, undefined)))}`, this.typeNode);
             }
         }
         // @ts-ignore
         if (this.typeNode.kind === ts.SyntaxKind.TemplateLiteralType) {
             const type = this.current.typeChecker.getTypeFromTypeNode(this.referencer || this.typeNode);
-            if (type.isUnion() && type.types.every(unionElementType => unionElementType.isStringLiteral())) {
+            if (type.isUnion() && type.types.every((unionElementType) => unionElementType.isStringLiteral())) {
                 return {
                     typeName: 'enum',
                     members: type.types.map((stringLiteralType) => stringLiteralType.value),
                 };
             }
-            else {
-                throw new error_1.ResolverError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode);
-            }
+            throw new error_1.ResolverError(`Could not the type of ${this.current.typeChecker.typeToString(this.current.typeChecker.getTypeFromTypeNode(this.typeNode), this.typeNode)}`, this.typeNode);
         }
         if (ts.isParenthesizedTypeNode(this.typeNode)) {
             return new TypeNodeResolver(this.typeNode.type, this.current, this.typeNode, this.context, this.referencer).resolve();
@@ -334,19 +334,19 @@ class TypeNodeResolver {
     }
     static getUtilityTypeOptions(typeArguments) {
         const utilityOptions = {
-            keys: []
+            keys: [],
         };
         if (typeArguments.length >= 2) {
             if (ts.isUnionTypeNode(typeArguments[1])) {
                 const args = typeArguments[1].types;
                 for (let i = 0; i < args.length; i++) {
                     if (ts.isLiteralTypeNode(args[i])) {
-                        utilityOptions['keys'].push(TypeNodeResolver.getLiteralValue(args[i]));
+                        utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(args[i]));
                     }
                 }
             }
             if (ts.isLiteralTypeNode(typeArguments[1])) {
-                utilityOptions['keys'].push(TypeNodeResolver.getLiteralValue(typeArguments[1]));
+                utilityOptions.keys.push(TypeNodeResolver.getLiteralValue(typeArguments[1]));
             }
         }
         return utilityOptions;
@@ -356,7 +356,7 @@ class TypeNodeResolver {
             return properties;
         }
         return properties
-            .filter(property => {
+            .filter((property) => {
             const name = typeof property.name !== 'string' ? property.name.text : property.name;
             switch (utilityType) {
                 case 'Pick':
@@ -366,7 +366,7 @@ class TypeNodeResolver {
             }
             return true;
         })
-            .map(property => {
+            .map((property) => {
             if ((0, metadata_utils_1.hasOwnProperty)(property, 'required')) {
                 switch (utilityType) {
                     case 'Partial':
@@ -434,21 +434,19 @@ class TypeNodeResolver {
                 return { typeName: 'double' };
             }
             const tags = (0, utils_1.getJSDocTagNames)(parentNode)
-                .filter(name => {
-                return [
-                    'isInt',
-                    'isLong',
-                    'isFloat',
-                    'isDouble'
-                ].some(m => m.toLowerCase() === name.toLowerCase());
-            })
-                .map(name => name.toLowerCase());
-            const data = (0, decorator_1.getNodeDecorators)(parentNode, identifier => [
+                .filter((name) => [
+                'isInt',
+                'isLong',
+                'isFloat',
+                'isDouble',
+            ].some((m) => m.toLowerCase() === name.toLowerCase()))
+                .map((name) => name.toLowerCase());
+            const data = (0, decorator_1.getNodeDecorators)(parentNode, (identifier) => [
                 'isInt',
                 'isLong',
                 'isFloat',
-                'isDouble'
-            ].some(m => m.toLowerCase() === identifier.text.toLowerCase()));
+                'isDouble',
+            ].some((m) => m.toLowerCase() === identifier.text.toLowerCase()));
             let decorator = data.length > 0 ? data[0].text : undefined;
             if (typeof decorator !== 'undefined') {
                 decorator = decorator.toLowerCase();
@@ -493,9 +491,7 @@ class TypeNodeResolver {
         if (!parentNode) {
             return { typeName: 'datetime' };
         }
-        const tags = (0, utils_1.getJSDocTagNames)(parentNode).filter(name => {
-            return ['isDate', 'isDateTime'].some(m => m === name);
-        });
+        const tags = (0, utils_1.getJSDocTagNames)(parentNode).filter((name) => ['isDate', 'isDateTime'].some((m) => m === name));
         if (tags.length === 0) {
             return { typeName: 'datetime' };
         }
@@ -513,7 +509,7 @@ class TypeNodeResolver {
     }
     getEnumerateType(typeName) {
         const enumName = typeName.text;
-        let enumNodes = this.current.nodes.filter(node => node.kind === ts.SyntaxKind.EnumDeclaration).filter(node => node.name.text === enumName);
+        let enumNodes = this.current.nodes.filter((node) => node.kind === ts.SyntaxKind.EnumDeclaration).filter((node) => node.name.text === enumName);
         if (!enumNodes.length) {
             return undefined;
         }
@@ -522,18 +518,16 @@ class TypeNodeResolver {
             throw new error_1.ResolverError(`Multiple matching enum found for enum ${enumName}; please make enum names unique.`);
         }
         const enumDeclaration = enumNodes[0];
-        const isNotUndefined = (item) => {
-            return item !== undefined;
-        };
+        const isNotUndefined = (item) => item !== undefined;
         const enums = enumDeclaration.members.map(this.current.typeChecker.getConstantValue.bind(this.current.typeChecker)).filter(isNotUndefined);
-        const enumNames = enumDeclaration.members.map(e => e.name.getText()).filter(isNotUndefined);
+        const enumNames = enumDeclaration.members.map((e) => e.name.getText()).filter(isNotUndefined);
         return {
             typeName: 'refEnum',
             description: this.getNodeDescription(enumDeclaration),
             members: enums,
             memberNames: enumNames,
             refName: enumName,
-            deprecated: (0, utils_1.isExistJSDocTag)(enumDeclaration, tag => tag.tagName.text === 'deprecated')
+            deprecated: (0, utils_1.isExistJSDocTag)(enumDeclaration, (tag) => tag.tagName.text === 'deprecated'),
         };
     }
     getReferenceType(node) {
@@ -545,14 +539,14 @@ class TypeNodeResolver {
             type = node.expression;
         }
         else {
-            throw new error_1.ResolverError(`Can't resolve Reference type.`);
+            throw new error_1.ResolverError('Can\'t resolve Reference type.');
         }
         // Can't invoke getText on Synthetic Nodes
         let resolvableName = node.pos !== -1 ? node.getText() : type.text;
         if (node.pos === -1 && 'typeArguments' in node && Array.isArray(node.typeArguments)) {
             // Add typeArguments for Synthetic nodes (e.g. Record<> in TestClassModel.indexedResponse)
             const argumentsString = node.typeArguments
-                .map(arg => {
+                .map((arg) => {
                 if (ts.isLiteralTypeNode(arg)) {
                     return `'${String(TypeNodeResolver.getLiteralValue(arg))}'`;
                 }
@@ -570,10 +564,10 @@ class TypeNodeResolver {
         const utilityTypeSupported = TypeNodeResolver.isSupportedUtilityType(identifierName);
         const utilityType = utilityTypeSupported ? identifierName : undefined;
         let utilityOptions = {
-            keys: []
+            keys: [],
         };
         if (utilityTypeSupported) {
-            const typeArguments = type.parent.typeArguments;
+            const { typeArguments } = type.parent;
             if (ts.isTypeReferenceNode(typeArguments[0])) {
                 type = typeArguments[0].typeName;
             }
@@ -581,7 +575,7 @@ class TypeNodeResolver {
                 type = typeArguments[0].expression;
             }
             else {
-                throw new error_1.ResolverError(`Can't resolve Reference type.`);
+                throw new error_1.ResolverError('Can\'t resolve Reference type.');
             }
             utilityOptions = TypeNodeResolver.getUtilityTypeOptions(typeArguments);
         }
@@ -614,7 +608,7 @@ class TypeNodeResolver {
                     members: [this.current.typeChecker.getConstantValue(declaration)],
                     // @ts-ignore
                     memberNames: [declaration.name.getText()],
-                    deprecated: (0, utils_1.isExistJSDocTag)(declaration, tag => tag.tagName.text === 'deprecated')
+                    deprecated: (0, utils_1.isExistJSDocTag)(declaration, (tag) => tag.tagName.text === 'deprecated'),
                 };
             }
             else {
@@ -642,25 +636,15 @@ class TypeNodeResolver {
             type = new TypeNodeResolver(declaration.type, this.current, declaration, this.context, this.referencer || referencer).resolve();
         }
         const example = TypeNodeResolver.getNodeExample(declaration);
-        return {
-            typeName: 'refAlias',
-            default: (0, utils_1.getJSDocTagComment)(declaration, 'default'),
-            description: this.getNodeDescription(declaration),
-            refName: refName,
-            format: TypeNodeResolver.getNodeFormat(declaration),
-            type: type,
-            validators: getPropertyValidators(declaration) || {},
-            deprecated: (0, utils_1.isExistJSDocTag)(declaration, tag => tag.tagName.text === 'deprecated'),
-            ...(example && { example: example }),
-        };
+        return Object.assign({ typeName: 'refAlias', default: (0, utils_1.getJSDocTagComment)(declaration, 'default'), description: this.getNodeDescription(declaration), refName, format: TypeNodeResolver.getNodeFormat(declaration), type, validators: getPropertyValidators(declaration) || {}, deprecated: (0, utils_1.isExistJSDocTag)(declaration, (tag) => tag.tagName.text === 'deprecated') }, (example && { example }));
     }
     getModelReference(modelType, name, utilityType, utilityOptions) {
         const example = TypeNodeResolver.getNodeExample(modelType);
         const description = this.getNodeDescription(modelType);
-        const deprecated = (0, utils_1.isExistJSDocTag)(modelType, tag => tag.tagName.text === 'deprecated') || typeof this.current.decoratorMapper.match('DEPRECATED', modelType) !== 'undefined';
+        const deprecated = (0, utils_1.isExistJSDocTag)(modelType, (tag) => tag.tagName.text === 'deprecated') || typeof this.current.decoratorMapper.match('DEPRECATED', modelType) !== 'undefined';
         // Handle toJSON methods
         if (!modelType.name) {
-            throw new error_1.ResolverError("Can't get Symbol from anonymous class", modelType);
+            throw new error_1.ResolverError('Can\'t get Symbol from anonymous class', modelType);
         }
         const type = this.current.typeChecker.getTypeAtLocation(modelType.name);
         const toJSON = this.current.typeChecker.getPropertyOfType(type, 'toJSON');
@@ -671,28 +655,12 @@ class TypeNodeResolver {
                 const implicitType = this.current.typeChecker.getReturnTypeOfSignature(signature);
                 nodeType = this.current.typeChecker.typeToTypeNode(implicitType, undefined, ts.NodeBuilderFlags.NoTruncation);
             }
-            return {
-                refName: TypeNodeResolver.getRefTypeName(name, utilityType) + 'Alias',
-                typeName: 'refAlias',
-                description: description,
-                type: new TypeNodeResolver(nodeType, this.current).resolve(),
-                deprecated: deprecated,
-                validators: {},
-                ...(example && { example: example }),
-            };
+            return Object.assign({ refName: `${TypeNodeResolver.getRefTypeName(name, utilityType)}Alias`, typeName: 'refAlias', description, type: new TypeNodeResolver(nodeType, this.current).resolve(), deprecated, validators: {} }, (example && { example }));
         }
         const properties = this.getModelProperties(modelType, undefined, utilityType, utilityOptions);
         const additionalProperties = this.getModelAdditionalProperties(modelType);
         const inheritedProperties = this.getModelInheritedProperties(modelType) || [];
-        const referenceType = {
-            additionalProperties: additionalProperties,
-            typeName: 'refObject',
-            description: description,
-            properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions),
-            refName: TypeNodeResolver.getRefTypeName(name, utilityType),
-            deprecated: deprecated,
-            ...(example && { example: example }),
-        };
+        const referenceType = Object.assign({ additionalProperties, typeName: 'refObject', description, properties: this.filterUtilityProperties(inheritedProperties, utilityType, utilityOptions), refName: TypeNodeResolver.getRefTypeName(name, utilityType), deprecated }, (example && { example }));
         referenceType.properties = referenceType.properties.concat(properties);
         return referenceType;
     }
@@ -713,31 +681,12 @@ class TypeNodeResolver {
             .replace(/_/g, '')
             .replace(/-/g, ''));
     }
-    attemptToResolveKindToPrimitive = (syntaxKind) => {
-        if (syntaxKind === ts.SyntaxKind.NumberKeyword) {
-            return 'number';
-        }
-        else if (syntaxKind === ts.SyntaxKind.StringKeyword) {
-            return 'string';
-        }
-        else if (syntaxKind === ts.SyntaxKind.BooleanKeyword) {
-            return 'boolean';
-        }
-        else if (syntaxKind === ts.SyntaxKind.VoidKeyword) {
-            return 'void';
-        }
-        else {
-            return undefined;
-        }
-    };
     contextualizedName(name) {
-        return Object.entries(this.context).reduce((acc, [key, entry]) => {
-            return acc
-                .replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `<$1${entry.getText()}$3>`)
-                .replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, 'g'), `<$1${entry.getText()}$3,`)
-                .replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `,$1${entry.getText()}$3>`)
-                .replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, 'g'), `<$1${entry.getText()}$3<`);
-        }, name);
+        return Object.entries(this.context).reduce((acc, [key, entry]) => acc
+            .replace(new RegExp(`<\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `<$1${entry.getText()}$3>`)
+            .replace(new RegExp(`<\\s*([^,]*\\s)*\\s*(${key})(\\s[^,]*)*\\s*,`, 'g'), `<$1${entry.getText()}$3,`)
+            .replace(new RegExp(`,\\s*([^>]*\\s)*\\s*(${key})(\\s[^>]*)*\\s*>`, 'g'), `,$1${entry.getText()}$3>`)
+            .replace(new RegExp(`<\\s*([^<]*\\s)*\\s*(${key})(\\s[^<]*)*\\s*<`, 'g'), `<$1${entry.getText()}$3<`), name);
     }
     handleCachingAndCircularReferences(name, declarationResolver) {
         try {
@@ -763,9 +712,9 @@ class TypeNodeResolver {
     createCircularDependencyResolver(refName) {
         const referenceType = {
             typeName: 'refObject',
-            refName: refName,
+            refName,
         };
-        this.current.registerDependencyResolver(referenceTypes => {
+        this.current.registerDependencyResolver((referenceTypes) => {
             const realReferenceType = referenceTypes[refName];
             if (!realReferenceType) {
                 return;
@@ -819,16 +768,14 @@ class TypeNodeResolver {
             const leftmostName = leftmost.kind === ts.SyntaxKind.Identifier ? leftmost.text : leftmost.right.text;
             const moduleDeclarations = this.findMatchingModuleOrEnumDeclaration(statements, leftmostName);
             if (moduleDeclarations.length > 0) {
-                statements = Array.prototype.concat(...moduleDeclarations.map(declaration => {
+                statements = Array.prototype.concat(...moduleDeclarations.map((declaration) => {
                     if (ts.isEnumDeclaration(declaration)) {
                         return declaration.members;
                     }
-                    else {
-                        if (!declaration.body || !ts.isModuleBlock(declaration.body)) {
-                            throw new error_1.ResolverError(`Module declaration found for ${leftmostName} has no body.`);
-                        }
-                        return declaration.body.statements;
+                    if (!declaration.body || !ts.isModuleBlock(declaration.body)) {
+                        throw new error_1.ResolverError(`Module declaration found for ${leftmostName} has no body.`);
                     }
+                    return declaration.body.statements;
                 }));
             }
             leftmost = leftmost.parent;
@@ -839,55 +786,52 @@ class TypeNodeResolver {
         const leftmostIdentifier = TypeNodeResolver.resolveLeftmostIdentifier(type);
         const statements = this.resolveModelTypeScope(leftmostIdentifier, this.current.nodes);
         const typeName = type.kind === ts.SyntaxKind.Identifier ? type.text : type.right.text;
-        let modelTypes = statements.filter(node => {
+        let modelTypes = statements.filter((node) => {
+            var _a;
             if (!TypeNodeResolver.nodeIsUsable(node) || !this.current.isExportedNode(node)) {
                 return false;
             }
             const modelTypeDeclaration = node;
-            return modelTypeDeclaration.name?.text === typeName;
+            return ((_a = modelTypeDeclaration.name) === null || _a === void 0 ? void 0 : _a.text) === typeName;
         });
         if (!modelTypes.length) {
             throw new error_1.ResolverError(`No matching model found for referenced type ${typeName}. If ${typeName} comes from a dependency, please create an interface in your own code that has the same structure. The compiler can not utilize interfaces from external dependencies.`);
         }
         if (modelTypes.length > 1) {
             // remove types that are from typescript e.g. 'Account'
-            modelTypes = modelTypes.filter(modelType => {
-                return modelType.getSourceFile().fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules') <= -1;
-            });
+            modelTypes = modelTypes.filter((modelType) => modelType.getSourceFile().fileName.replace(/\\/g, '/').toLowerCase().indexOf('node_modules') <= -1);
             modelTypes = TypeNodeResolver.getDesignatedModels(modelTypes, typeName);
         }
         if (modelTypes.length > 1) {
-            const conflicts = modelTypes.map(modelType => modelType.getSourceFile().fileName).join('"; "');
+            const conflicts = modelTypes.map((modelType) => modelType.getSourceFile().fileName).join('"; "');
             throw new error_1.ResolverError(`Multiple matching models found for referenced type ${typeName}; please make model names unique. Conflicts found: "${conflicts}".`);
         }
         return modelTypes[0];
     }
     getModelProperties(node, overrideToken, utilityType, utilityOptions) {
-        const isIgnored = (e) => {
-            return (0, utils_1.isExistJSDocTag)(e, tag => tag.tagName.text === 'ignore');
-        };
+        const isIgnored = (e) => (0, utils_1.isExistJSDocTag)(e, (tag) => tag.tagName.text === 'ignore');
         // Interface model
         if (ts.isInterfaceDeclaration(node)) {
-            return node.members.filter(member => !isIgnored(member) && ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
+            return node.members.filter((member) => !isIgnored(member) && ts.isPropertySignature(member)).map((member) => this.propertyFromSignature(member, overrideToken));
         }
         // Class model
         let properties = node.members
-            .filter(member => !isIgnored(member))
-            .filter(member => member.kind === ts.SyntaxKind.PropertyDeclaration)
-            .filter(member => !this.hasStaticModifier(member))
-            .filter(member => this.hasPublicModifier(member));
-        const classConstructor = node.members.find(member => ts.isConstructorDeclaration(member));
+            .filter((member) => !isIgnored(member))
+            .filter((member) => member.kind === ts.SyntaxKind.PropertyDeclaration)
+            .filter((member) => !this.hasStaticModifier(member))
+            .filter((member) => this.hasPublicModifier(member));
+        const classConstructor = node.members.find((member) => ts.isConstructorDeclaration(member));
         if (classConstructor && classConstructor.parameters) {
-            const constructorProperties = classConstructor.parameters.filter(parameter => this.isAccessibleParameter(parameter));
+            const constructorProperties = classConstructor.parameters.filter((parameter) => this.isAccessibleParameter(parameter));
             properties.push(...constructorProperties);
         }
         properties = this.filterUtilityProperties(properties, utilityType, utilityOptions);
-        return properties.map(property => this.propertyFromDeclaration(property, overrideToken, utilityType));
+        return properties.map((property) => this.propertyFromDeclaration(property, overrideToken, utilityType));
     }
     propertyFromSignature(propertySignature, overrideToken) {
         const identifier = propertySignature.name;
         if (!propertySignature.type) {
-            throw new error_1.ResolverError(`No valid type found for property declaration.`);
+            throw new error_1.ResolverError('No valid type found for property declaration.');
         }
         let required = !propertySignature.questionToken;
         if (overrideToken && overrideToken.kind === ts.SyntaxKind.MinusToken) {
@@ -897,15 +841,15 @@ class TypeNodeResolver {
             required = false;
         }
         const property = {
-            deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, tag => tag.tagName.text === 'deprecated'),
+            deprecated: (0, utils_1.isExistJSDocTag)(propertySignature, (tag) => tag.tagName.text === 'deprecated'),
             default: (0, utils_1.getJSDocTagComment)(propertySignature, 'default'),
             description: this.getNodeDescription(propertySignature),
             example: TypeNodeResolver.getNodeExample(propertySignature),
             format: TypeNodeResolver.getNodeFormat(propertySignature),
             name: identifier.text,
-            required: required,
+            required,
             type: new TypeNodeResolver(propertySignature.type, this.current, propertySignature.type.parent, this.context, propertySignature.type).resolve(),
-            validators: getPropertyValidators(propertySignature) || {}
+            validators: getPropertyValidators(propertySignature) || {},
         };
         return property;
     }
@@ -917,7 +861,7 @@ class TypeNodeResolver {
             typeNode = this.current.typeChecker.typeToTypeNode(tsType, undefined, ts.NodeBuilderFlags.NoTruncation);
         }
         if (!typeNode) {
-            throw new error_1.ResolverError(`No valid type found for property declaration.`);
+            throw new error_1.ResolverError('No valid type found for property declaration.');
         }
         const type = new TypeNodeResolver(typeNode, this.current, propertyDeclaration, this.context, typeNode).resolve();
         let required = !propertyDeclaration.questionToken && !propertyDeclaration.initializer;
@@ -936,28 +880,28 @@ class TypeNodeResolver {
             }
         }
         const property = {
-            deprecated: (0, utils_1.isExistJSDocTag)(propertyDeclaration, tag => tag.tagName.text === 'deprecated'),
+            deprecated: (0, utils_1.isExistJSDocTag)(propertyDeclaration, (tag) => tag.tagName.text === 'deprecated'),
             default: (0, utils_2.getInitializerValue)(propertyDeclaration.initializer, this.current.typeChecker),
             description: this.getNodeDescription(propertyDeclaration),
             example: TypeNodeResolver.getNodeExample(propertyDeclaration),
             format: TypeNodeResolver.getNodeFormat(propertyDeclaration),
             name: identifier.text,
-            required: required,
-            type: type,
+            required,
+            type,
             validators: getPropertyValidators(propertyDeclaration) || {},
         };
         return property;
     }
     getModelAdditionalProperties(node) {
         if (node.kind === ts.SyntaxKind.InterfaceDeclaration) {
-            const indexMember = node.members.find(member => member.kind === ts.SyntaxKind.IndexSignature);
+            const indexMember = node.members.find((member) => member.kind === ts.SyntaxKind.IndexSignature);
             if (!indexMember) {
                 return undefined;
             }
             const indexSignatureDeclaration = indexMember;
             const indexType = new TypeNodeResolver(indexSignatureDeclaration.parameters[0].type, this.current, this.parentNode, this.context).resolve();
             if (indexType.typeName !== 'string') {
-                throw new error_1.ResolverError(`Only string indexers are supported.`, this.typeNode);
+                throw new error_1.ResolverError('Only string indexers are supported.', this.typeNode);
             }
             return new TypeNodeResolver(indexSignatureDeclaration.type, this.current, this.parentNode, this.context).resolve();
         }
@@ -985,25 +929,22 @@ class TypeNodeResolver {
                 else {
                     throw new error_1.ResolverError(`Could not find a value for type parameter ${typeParameter.name.text}`, type);
                 }
-                this.context = {
-                    ...this.context,
-                    [typeParameter.name.text]: resolvedType,
-                };
+                this.context = Object.assign(Object.assign({}, this.context), { [typeParameter.name.text]: resolvedType });
             }
         }
         return context;
     }
     getModelInheritedProperties(modelTypeDeclaration) {
         let properties = [];
-        const heritageClauses = modelTypeDeclaration.heritageClauses;
+        const { heritageClauses } = modelTypeDeclaration;
         if (!heritageClauses) {
             return properties;
         }
-        heritageClauses.forEach(clause => {
+        heritageClauses.forEach((clause) => {
             if (!clause.types) {
                 return;
             }
-            clause.types.forEach(t => {
+            clause.types.forEach((t) => {
                 const baseEntityName = t.expression;
                 // create subContext
                 const resetCtx = this.typeArgumentsToContext(t, baseEntityName, this.context);
@@ -1025,7 +966,7 @@ class TypeNodeResolver {
                         }
                     }
                     else if (referenceType.typeName === 'refObject') {
-                        referenceType.properties.forEach(property => properties.push(property));
+                        referenceType.properties.forEach((property) => properties.push(property));
                     }
                     else {
                         // todo: should never assert
@@ -1039,15 +980,11 @@ class TypeNodeResolver {
     }
     hasPublicModifier(node) {
         return (!node.modifiers ||
-            node.modifiers.every(modifier => {
-                return modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword;
-            }));
+            node.modifiers.every((modifier) => modifier.kind !== ts.SyntaxKind.ProtectedKeyword && modifier.kind !== ts.SyntaxKind.PrivateKeyword));
     }
     hasStaticModifier(node) {
         return (node.modifiers &&
-            node.modifiers.some(modifier => {
-                return modifier.kind === ts.SyntaxKind.StaticKeyword;
-            }));
+            node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword));
     }
     isAccessibleParameter(node) {
         // No modifiers
@@ -1055,14 +992,12 @@ class TypeNodeResolver {
             return false;
         }
         // public || public readonly
-        if (node.modifiers.some(modifier => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
+        if (node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.PublicKeyword)) {
             return true;
         }
         // readonly, not private readonly, not public readonly
-        const isReadonly = node.modifiers.some(modifier => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
-        const isProtectedOrPrivate = node.modifiers.some(modifier => {
-            return modifier.kind === ts.SyntaxKind.ProtectedKeyword || modifier.kind === ts.SyntaxKind.PrivateKeyword;
-        });
+        const isReadonly = node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ReadonlyKeyword);
+        const isProtectedOrPrivate = node.modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ProtectedKeyword || modifier.kind === ts.SyntaxKind.PrivateKeyword);
         return isReadonly && !isProtectedOrPrivate;
     }
     getNodeDescription(node) {
@@ -1093,7 +1028,7 @@ class TypeNodeResolver {
             try {
                 return JSON.parse(example);
             }
-            catch {
+            catch (_a) {
                 return undefined;
             }
         }