@player-tools/xlr-converters 0.2.2--canary.17.363 → 0.3.0-next.0

package/dist/index.cjs.js

@@ -59,25 +59,34 @@ class TsConverter {
     };
   }
   convertSourceFile(sourceFile) {
-    const declarations = sourceFile.statements.filter((statement) => ts__default["default"].isTypeAliasDeclaration(statement) || ts__default["default"].isInterfaceDeclaration(statement));
-    const types = declarations.filter((declaration) => xlrUtils.isExportedDeclaration(declaration)).map((statement) => this.convertDeclaration(statement)).filter((v) => !!v);
+    const declarations = sourceFile.statements.filter(xlrUtils.isTopLevelNode);
+    const types = declarations.filter((declaration) => xlrUtils.isExportedDeclaration(declaration)).map((statement) => this.convertTopLevelNode(statement)).filter((v) => !!v);
     return {
       data: { version: 1, types },
       convertedTypes: types.map(({ name }) => name)
     };
   }
-  convertDeclaration(node) {
-    var _a;
+  convertTopLevelNode(node) {
     const sourceFile = node.parent;
     const { fileName } = sourceFile;
+    if (ts__default["default"].isVariableStatement(node)) {
+      return __spreadValues$1({
+        source: fileName
+      }, this.convertVariable(node));
+    }
+    return __spreadValues$1({
+      source: fileName
+    }, this.convertDeclaration(node));
+  }
+  convertDeclaration(node) {
+    var _a;
     if (ts__default["default"].isTypeAliasDeclaration(node)) {
       let genericTokens;
       if (xlrUtils.isGenericTypeDeclaration(node)) {
         genericTokens = this.generateGenerics(node.typeParameters);
       }
       return __spreadProps(__spreadValues$1(__spreadValues$1({
-        name: node.name.getText(),
-        source: fileName
+        name: node.name.getText()
       }, (_a = this.convertTsTypeNode(node.type)) != null ? _a : AnyTypeNode), xlrUtils.decorateNode(node)), {
         genericTokens
       });
@@ -89,9 +98,8 @@ class TsConverter {
       }
       const baseObject = __spreadProps(__spreadValues$1(__spreadValues$1({
         name: node.name.getText(),
-        type: "object",
-        source: fileName
-      }, this.fromTsObjectMembers(node)), xlrUtils.decorateNode(node)), {
+        type: "object"
+      }, this.tsObjectMembersToProperties(node)), xlrUtils.decorateNode(node)), {
         genericTokens
       });
       if (node.heritageClauses) {
@@ -101,6 +109,24 @@ class TsConverter {
     }
     this.context.throwError(`Error: type node is not an Interface or a Type, can't convert as Declaration`);
   }
+  convertVariable(node) {
+    const variableDeclarations = node.declarationList.declarations;
+    if (variableDeclarations.length === 1) {
+      const variable = variableDeclarations[0];
+      if (variable.initializer) {
+        let resultingNode;
+        if (ts__default["default"].isCallExpression(variable.initializer) || ts__default["default"].isArrowFunction(variable.initializer)) {
+          resultingNode = this.resolveFunctionCall(variable.initializer, node.parent);
+        } else {
+          resultingNode = this.tsLiteralToType(variable.initializer);
+        }
+        return __spreadValues$1({
+          name: variable.name.getText()
+        }, resultingNode);
+      }
+    }
+    this.context.throwError(`Error: Multi-variable declaration on line ${node.pos} is not supported for conversion`);
+  }
   convertTsTypeNode(node) {
     if (this.context.cache.convertedNodes.has(node)) {
       const cachedType = this.context.cache.convertedNodes.get(node);
@@ -125,7 +151,10 @@ class TsConverter {
       }, xlrUtils.decorateNode(node));
     }
     if (ts__default["default"].isParenthesizedTypeNode(node)) {
-      const children = [...node.getChildren()];
+      const children = [];
+      node.forEachChild((child) => {
+        children.push(child);
+      });
       if (((_a = children[0]) == null ? void 0 : _a.kind) === ts__default["default"].SyntaxKind.OpenParenToken) {
         children.shift();
       }
@@ -166,6 +195,11 @@ class TsConverter {
         additionalProperties: AnyTypeNode
       }, xlrUtils.decorateNode(node));
     }
+    if (node.kind === ts__default["default"].SyntaxKind.VoidKeyword) {
+      return __spreadValues$1({
+        type: "void"
+      }, xlrUtils.decorateNode(node));
+    }
     if (ts__default["default"].isTemplateLiteralTypeNode(node)) {
       let format;
       if (this.context.cache.convertedTemplates.has(node)) {
@@ -205,45 +239,17 @@ class TsConverter {
     if (ts__default["default"].isTupleTypeNode(node)) {
       return __spreadValues$1(__spreadValues$1({
         type: "tuple"
-      }, this.fromTsTuple(node)), xlrUtils.decorateNode(node));
+      }, this.tsTupleToType(node)), xlrUtils.decorateNode(node));
     }
     if (ts__default["default"].isLiteralTypeNode(node)) {
-      if (ts__default["default"].isNumericLiteral(node.literal)) {
-        return __spreadValues$1({
-          type: "number",
-          const: Number(node.literal.text)
-        }, xlrUtils.decorateNode(node));
-      }
-      if (ts__default["default"].isStringLiteral(node.literal)) {
-        return __spreadValues$1({
-          type: "string",
-          const: node.literal.text
-        }, xlrUtils.decorateNode(node));
-      }
-      if (node.literal.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
-        return __spreadValues$1({
-          type: "boolean",
-          const: true
-        }, xlrUtils.decorateNode(node));
-      }
-      if (node.literal.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
-        return __spreadValues$1({
-          type: "boolean",
-          const: false
-        }, xlrUtils.decorateNode(node));
-      }
-      if (node.literal.kind === ts__default["default"].SyntaxKind.NullKeyword) {
-        return __spreadValues$1({ type: "null" }, xlrUtils.decorateNode(node));
-      }
-      if (node.literal.kind === ts__default["default"].SyntaxKind.PrefixUnaryExpression) {
-        this.context.throwError("Prefix unary expressions not supported");
-      }
-      this.context.throwError("Literal type not understood");
-    } else if (ts__default["default"].isTypeLiteralNode(node)) {
+      return this.tsLiteralToType(node.literal);
+    }
+    if (ts__default["default"].isTypeLiteralNode(node)) {
       return __spreadValues$1(__spreadValues$1({
         type: "object"
-      }, this.fromTsObjectMembers(node)), xlrUtils.decorateNode(node));
-    } else if (ts__default["default"].isFunctionTypeNode(node)) {
+      }, this.tsObjectMembersToProperties(node)), xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isFunctionTypeNode(node) || ts__default["default"].isFunctionDeclaration(node) || ts__default["default"].isArrowFunction(node)) {
       const parameters = node.parameters.map((param) => {
         let typeNode;
         if (param.type) {
@@ -256,13 +262,17 @@ class TsConverter {
           default: param.initializer ? this.convertTsTypeNode(param.initializer) : void 0
         };
       });
-      const returnType = node.type.kind === ts__default["default"].SyntaxKind.VoidKeyword ? void 0 : this.convertTsTypeNode(node.type);
+      let returnType;
+      if (node.type !== void 0) {
+        returnType = this.convertTsTypeNode(node.type);
+      }
       return __spreadValues$1({
         type: "function",
         parameters,
         returnType
       }, xlrUtils.decorateNode(node));
-    } else if (ts__default["default"].isIndexedAccessTypeNode(node)) {
+    }
+    if (ts__default["default"].isIndexedAccessTypeNode(node)) {
       if (ts__default["default"].isTypeReferenceNode(node.objectType) && ts__default["default"].isLiteralTypeNode(node.indexType)) {
         const baseObject = this.convertTsTypeNode(node.objectType);
         const accessor = node.indexType.literal.getText().replace(/["']/g, "");
@@ -282,36 +292,147 @@ class TsConverter {
         }
       }
       if (ts__default["default"].isTypeQueryNode(node.objectType)) {
-        const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
-        if (ts__default["default"].TypeFlags.Union & effectiveType.flags) {
-          return {
-            type: "or",
-            or: effectiveType.types.map((type) => {
-              if (ts__default["default"].TypeFlags.StringLiteral & type.flags) {
-                return {
-                  type: "string",
-                  const: type.value
-                };
-              }
-              if (ts__default["default"].TypeFlags.NumberLiteral & type.flags) {
-                return {
-                  type: "number",
-                  const: type.value
-                };
-              }
-              return {
-                type: "unknown"
-              };
-            })
+        const elements = this.tsNodeToType(node.objectType);
+        return {
+          type: "or",
+          or: [...elements.elementTypes.map((element) => element.type)]
+        };
+      }
+      this.context.throwError(`Error: could not solve IndexedAccessType ${node.getFullText()}`);
+    }
+    if (ts__default["default"].isTypeQueryNode(node)) {
+      const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+      const syntheticType = this.context.typeChecker.typeToTypeNode(effectiveType, node, void 0);
+      if (syntheticType) {
+        return this.tsNodeToType(syntheticType);
+      }
+      this.context.throwError(`Error: could not synthesize type for ${node.getText()}`);
+    }
+    if (ts__default["default"].isTypeOperatorNode(node)) {
+      return this.tsNodeToType(node.type);
+    }
+    this.context.throwError(`Unimplemented type ${ts__default["default"].SyntaxKind[node.kind]} at ${node.getText()}`);
+  }
+  tsLiteralToType(node) {
+    if (ts__default["default"].isNumericLiteral(node)) {
+      return __spreadValues$1({
+        type: "number",
+        const: Number(node.text)
+      }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isStringLiteral(node)) {
+      return __spreadValues$1({
+        type: "string",
+        const: node.text
+      }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.TrueKeyword) {
+      return __spreadValues$1({
+        type: "boolean",
+        const: true
+      }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.FalseKeyword) {
+      return __spreadValues$1({
+        type: "boolean",
+        const: false
+      }, xlrUtils.decorateNode(node));
+    }
+    if (node.kind === ts__default["default"].SyntaxKind.NullKeyword) {
+      return __spreadValues$1({ type: "null" }, xlrUtils.decorateNode(node));
+    }
+    if (ts__default["default"].isPrefixUnaryExpression(node)) {
+      this.context.throwError("Prefix unary expressions not supported");
+    }
+    if (ts__default["default"].isArrayLiteralExpression(node)) {
+      const arrayElements = [];
+      node.elements.forEach((element) => {
+        var _a;
+        if (ts__default["default"].isSpreadElement(element)) {
+          const arrayReference = this.resolveLiteralReference(element.expression);
+          arrayElements.push(...(_a = arrayReference.const) != null ? _a : []);
+        } else {
+          arrayElements.push(this.tsLiteralToType(element));
+        }
+      });
+      return {
+        type: "array",
+        elementType: { type: "any" },
+        const: arrayElements
+      };
+    }
+    if (ts__default["default"].isObjectLiteralExpression(node)) {
+      const ret = {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      };
+      node.properties.forEach((property) => {
+        var _a;
+        if (ts__default["default"].isPropertyAssignment(property)) {
+          const propertyName = (_a = property.name) == null ? void 0 : _a.getText();
+          ret.properties[propertyName] = {
+            required: true,
+            node: this.tsLiteralToType(property.initializer)
           };
+        } else if (ts__default["default"].isSpreadAssignment(property)) {
+          const spreadValue = this.resolveLiteralReference(property.expression);
+          ret.properties = __spreadValues$1(__spreadValues$1({}, ret.properties), spreadValue.properties);
         }
+      });
+      return ret;
+    }
+    if (ts__default["default"].isIdentifier(node)) {
+      return this.resolveLiteralReference(node);
+    }
+    this.context.throwError(`Literal type not understood ${ts__default["default"].SyntaxKind[node.kind]} at ${node.getText()}`);
+  }
+  resolveLiteralReference(expression) {
+    var _a, _b;
+    if (ts__default["default"].isIdentifier(expression)) {
+      const symbol = this.context.typeChecker.getSymbolAtLocation(expression);
+      let expressionReference = (_a = symbol == null ? void 0 : symbol.declarations) == null ? void 0 : _a[0];
+      if (symbol && expressionReference && ts__default["default"].isImportSpecifier(expressionReference)) {
+        const referencedDeclaration = this.context.typeChecker.getAliasedSymbol(symbol);
+        expressionReference = (_b = referencedDeclaration.declarations) == null ? void 0 : _b[0];
       }
-      this.context.throwError(`Error: could not solve IndexedAccessType ${node.getFullText()}`);
-    } else {
-      this.context.throwError(`Unimplemented type ${ts__default["default"].SyntaxKind[node.kind]}`);
+      if (expressionReference && ts__default["default"].isVariableDeclaration(expressionReference) && expressionReference.initializer) {
+        return this.convertVariable(expressionReference.parent.parent);
+      }
+      this.context.throwError(`Error: Can't resolve non-variable declaration ${expressionReference == null ? void 0 : expressionReference.getText()}`);
+    }
+    this.context.throwError(`Error: Can't resolve non-identifier reference in literal ${expression.getText()}`);
+  }
+  resolveFunctionCall(functionCall, document) {
+    var _a;
+    if (ts__default["default"].isArrowFunction(functionCall)) {
+      const declaredReturnType = functionCall.parent.type;
+      if (declaredReturnType) {
+        return this.tsNodeToType(declaredReturnType);
+      }
+    }
+    const functionReturnType = this.context.typeChecker.getTypeAtLocation(functionCall);
+    const syntheticNode = this.context.typeChecker.typeToTypeNode(functionReturnType, document, void 0);
+    if (syntheticNode) {
+      if (ts__default["default"].isTypeReferenceNode(syntheticNode) && ts__default["default"].isIdentifier(syntheticNode.typeName)) {
+        const { typeName } = syntheticNode;
+        if (this.context.customPrimitives.includes(typeName.text)) {
+          return this.makeBasicRefNode(syntheticNode);
+        }
+        const declarationSymbol = typeName.symbol;
+        if (declarationSymbol && ((_a = declarationSymbol.declarations) == null ? void 0 : _a[0])) {
+          const declaration = declarationSymbol.declarations[0];
+          if (ts__default["default"].isTypeAliasDeclaration(declaration) || ts__default["default"].isInterfaceDeclaration(declaration)) {
+            return this.convertDeclaration(declaration);
+          }
+        }
+        this.context.throwError(`Error: could not get referenced type ${syntheticNode.getText()}`);
+      }
+      return this.tsNodeToType(syntheticNode);
     }
+    this.context.throwError(`Error: could not determine effective return type of ${functionCall.getText()}`);
   }
-  fromTsObjectMembers(node) {
+  tsObjectMembersToProperties(node) {
     const ret = {
       properties: {},
       additionalProperties: false
@@ -334,7 +455,7 @@ class TsConverter {
     });
     return ret;
   }
-  fromTsTuple(node) {
+  tsTupleToType(node) {
     var _a;
     if (node.elements.length === 0) {
       return { elementTypes: [], additionalItems: false, minItems: 0 };
@@ -345,11 +466,24 @@ class TsConverter {
       node.elements[node.elements.length - 1]
     ] : [[...node.elements], void 0];
     const elementTypes = elements.map((element) => {
-      var _a2;
-      return (_a2 = this.convertTsTypeNode(xlrUtils.tsStripOptionalType(element))) != null ? _a2 : AnyTypeNode;
+      if (ts__default["default"].isNamedTupleMember(element)) {
+        let typeNode;
+        if (element.type) {
+          typeNode = this.convertTsTypeNode(element.type);
+        }
+        return {
+          name: element.name.text,
+          type: typeNode != null ? typeNode : AnyTypeNode,
+          optional: element.questionToken ? true : void 0
+        };
+      }
+      return {
+        type: this.convertTsTypeNode(xlrUtils.tsStripOptionalType(element)),
+        optional: ts__default["default"].isOptionalTypeNode(element)
+      };
     });
     const additionalItems = rest ? (_a = this.convertTsTypeNode(rest.type.elementType)) != null ? _a : AnyTypeNode : false;
-    const firstOptional = elements.findIndex((element) => ts__default["default"].isOptionalTypeNode(element));
+    const firstOptional = elementTypes.findIndex((element) => element.optional === true);
     const minItems = firstOptional === -1 ? elements.length : firstOptional;
     return __spreadProps(__spreadValues$1({
       elementTypes
@@ -390,7 +524,7 @@ class TsConverter {
             extendsType = typeToApply.extends;
           }
           if (parentInterface.typeParameters && parent.typeArguments) {
-            typeToApply = this.solveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
+            typeToApply = this.resolveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
           } else if (xlrUtils.isGenericNodeType(baseObject)) {
             baseObject.genericTokens.push(...(_a = typeToApply.genericTokens) != null ? _a : []);
           }
@@ -417,7 +551,7 @@ class TsConverter {
       additionalProperties
     });
   }
-  solveGenerics(baseInterface, typeParameters, typeArguments) {
+  resolveGenerics(baseInterface, typeParameters, typeArguments) {
     if (typeArguments && typeArguments.length === 0)
       return baseInterface;
     const genericMap = new Map();
@@ -504,11 +638,11 @@ class TsConverter {
     if (!this.context.customPrimitives.includes(refName)) {
       const typeInfo = xlrUtils.getReferencedType(node, this.context.typeChecker);
       if (typeInfo) {
-        const genericType = this.convertDeclaration(typeInfo.declaration);
+        const genericType = this.convertTopLevelNode(typeInfo.declaration);
         const genericParams = typeInfo.declaration.typeParameters;
         const genericArgs = node.typeArguments;
         if (genericType && genericParams && genericArgs) {
-          return this.solveGenerics(genericType, genericParams, genericArgs);
+          return this.resolveGenerics(genericType, genericParams, genericArgs);
         }
         if (genericType) {
           return genericType;
@@ -540,7 +674,7 @@ class TsConverter {
     if (node.typeArguments) {
       node.typeArguments.forEach((typeArg) => {
         let convertedNode;
-        if (xlrUtils.isTopLevelNode(typeArg)) {
+        if (xlrUtils.isTopLevelDeclaration(typeArg)) {
           convertedNode = this.convertDeclaration(typeArg);
         } else {
           convertedNode = this.convertTsTypeNode(typeArg);
@@ -552,9 +686,15 @@ class TsConverter {
         }
       });
     }
+    let ref;
+    if (node.pos === -1 && ts__default["default"].isTypeReferenceNode(node) && ts__default["default"].isIdentifier(node.typeName)) {
+      ref = node.typeName.text;
+    } else {
+      ref = node.getText();
+    }
     return __spreadProps(__spreadValues$1({
       type: "ref",
-      ref: node.getText()
+      ref
     }, xlrUtils.decorateNode(node)), {
       genericArguments: genericArgs.length > 0 ? genericArgs : void 0
     });
@@ -605,10 +745,6 @@ class TSWriter {
   convertNamedTypeNode(type) {
     const typeName = type.name;
     const tsNode = this.convertTypeNode(type);
-    let generics;
-    if (xlrUtils.isGenericNamedType(type)) {
-      generics = this.createTypeParameters(type);
-    }
     let customPrimitiveHeritageClass;
     if (type.type === "object" && type.extends) {
       const refName = type.extends.ref.split("<")[0];
@@ -618,6 +754,15 @@ class TSWriter {
         ])
       ];
     }
+    let generics;
+    if (xlrUtils.isGenericNamedType(type)) {
+      generics = this.createTypeParameters(type);
+      type.genericTokens.forEach((token) => {
+        if (this.importSet.has(token.symbol)) {
+          this.importSet.delete(token.symbol);
+        }
+      });
+    }
     let finalNode;
     if (ts__default["default"].isTypeLiteralNode(tsNode)) {
       finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics, customPrimitiveHeritageClass);
@@ -641,6 +786,9 @@ class TSWriter {
       }));
     }
     if (type.type === "array") {
+      if (type.const) {
+        return this.context.factory.createTupleTypeNode(type.const.map((element) => this.convertTypeNode(element)));
+      }
       return this.context.factory.createTypeReferenceNode(this.context.factory.createIdentifier("Array"), [this.convertTypeNode(type.elementType)]);
     }
     if (xlrUtils.isPrimitiveTypeNode(type)) {
@@ -667,6 +815,7 @@ class TSWriter {
     this.context.throwError(`Unable to convert node type: ${type.type}`);
   }
   createRefNode(xlrNode) {
+    const typeArgs = [];
     if (xlrNode.genericArguments) {
       xlrNode.genericArguments.forEach((genericArg) => {
         if (genericArg.name) {
@@ -686,12 +835,14 @@ class TSWriter {
               this.additionalTypes.set(type.name, additionalType);
             }
           });
+        } else {
+          typeArgs.push(this.convertTypeNode(genericArg));
         }
       });
     }
     const importName = xlrNode.ref.split("<")[0];
     this.importSet.add(importName);
-    return this.context.factory.createTypeReferenceNode(xlrNode.ref);
+    return this.context.factory.createTypeReferenceNode(importName, typeArgs);
   }
   createPrimitiveNode(xlrNode) {
     if ((xlrNode.type === "string" || xlrNode.type === "boolean" || xlrNode.type === "number") && xlrNode.const || xlrNode.type === "null") {
@@ -712,6 +863,8 @@ class TSWriter {
         return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.NeverKeyword);
       case "undefined":
         return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.UndefinedKeyword);
+      case "void":
+        return this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.VoidKeyword);
       default:
         this.context.throwError(`Unknown primitive type ${xlrNode.type}`);
     }
@@ -732,7 +885,12 @@ class TSWriter {
     this.context.throwError(`Can't make literal out of type ${xlrNode.type}`);
   }
   createTupleNode(xlrNode) {
-    return this.context.factory.createTupleTypeNode(xlrNode.elementTypes.map((e) => this.convertTypeNode(e)));
+    return this.context.factory.createTupleTypeNode(xlrNode.elementTypes.map((e) => {
+      if (e.name) {
+        return this.context.factory.createNamedTupleMember(void 0, this.context.factory.createIdentifier(e.name), e.optional ? this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type));
+      }
+      return this.convertTypeNode(e.type);
+    }));
   }
   createFunctionDeclarationNode(xlrNode) {
     return this.context.factory.createFunctionTypeNode(void 0, xlrNode.parameters.map((e) => {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
-import { NodeType, NamedType, ObjectType, NamedTypeWithGenerics } from '@player-tools/xlr';
-import { TopLevelDeclaration } from '@player-tools/xlr-utils';
+import { NodeType, NamedType, NamedTypeWithGenerics, ObjectType, NodeTypeWithGenerics } from '@player-tools/xlr';
+import { TopLevelNode, TopLevelDeclaration } from '@player-tools/xlr-utils';
 
 interface TSConverterContext {
     /** */
@@ -29,15 +29,21 @@ declare class TsConverter {
         };
         convertedTypes: string[];
     };
+    convertTopLevelNode(node: TopLevelNode): NamedType | NamedTypeWithGenerics;
     /** Converts a single type/interface declaration to XLRs */
-    convertDeclaration(node: TopLevelDeclaration): NamedType<ObjectType> | NamedTypeWithGenerics<ObjectType>;
+    convertDeclaration(node: TopLevelDeclaration): ObjectType | NodeTypeWithGenerics<ObjectType>;
+    convertVariable(node: ts.VariableStatement): NodeType;
     /** Converts an arbitrary ts.TypeNode to XLRs */
-    convertTsTypeNode(node: ts.TypeNode): NodeType | undefined;
+    convertTsTypeNode(node: ts.TypeNode): NodeType;
+    /** Should not be called directly unless you want to bypass the cache, use `convertTsTypeNode` */
     private tsNodeToType;
-    private fromTsObjectMembers;
-    private fromTsTuple;
+    private tsLiteralToType;
+    private resolveLiteralReference;
+    private resolveFunctionCall;
+    private tsObjectMembersToProperties;
+    private tsTupleToType;
     private handleHeritageClauses;
-    private solveGenerics;
+    private resolveGenerics;
     private generateGenerics;
     private resolveRefNode;
     private makeMappedType;