refactor: move resolving function to the import manager

src/parser.ts

@@ -3,7 +3,7 @@ import { createSourceFile, isEnumDeclaration, isImportDeclaration, isLiteralType
 import { FileManager } from "./utils/FileManager"
 import { ArrayType } from "./models/ArrayType"
 import { ArrayTypeDeclaration } from "./models/ArrayTypeDeclaration"
-import { Import } from "./models/Import"
+import { Import } from "./utils/imports/model"
 import { IntersectionType } from "./models/IntersectionType"
 import { IntersectionTypeDeclaration } from "./models/IntersectionTypeDeclaration"
 import { StringType } from "./models/StringType"
@@ -142,7 +142,7 @@ export class Parser {
 	// - remove import
 	// - parse
 	private resolveImport(imported: Import) {
-		const path = imported.resolve()
+		const path = this.importManager.resolve(imported)
 		this.parseFile(path)
 		this.importManager.remove(imported)
 	}

src/utils/imports/errors.ts

@@ -0,0 +1,17 @@
+import { Import } from "./model"
+
+export class UnresolvedImportError extends Error {
+	constructor(imp: Import) {
+		super()
+		this.message = this.createMessage(imp)
+	}
+
+	private createMessage(imp: Import): string {
+		return [
+			`Could not resolve ${imp.toString()} from "${imp.from}".`,
+			"",
+			"It is possible to suppress this error when the 'breakOnUnresolvedImport' options is set to 'false'.",
+			"The type will resolve to unknown then.",
+		].join("\n")
+	}
+}

src/utils/imports/factory.ts

@@ -1,5 +1,5 @@
 import { ImportDeclaration, isImportClause, isImportSpecifier, isNamedImports, isStringLiteralLike } from "typescript"
-import { Import } from "../../models/Import"
+import { Import } from "./model"
 
 /**
  * For translating `typescript` AST nodes into our own model type.

src/utils/imports/manager.ts

@@ -1,4 +1,8 @@
-import { Import } from "../../models/Import"
+import { existsSync } from "fs"
+import { resolve } from "path"
+import { Import } from "./model"
+import { L } from "../logger"
+import { UnresolvedImportError } from "./errors"
 
 export class ImportManager {
 	private imports: Array<Import> = []
@@ -17,4 +21,39 @@ export class ImportManager {
 	public remove(i: Import) {
 		this.imports.splice(this.imports.indexOf(i), 1)
 	}
+
+	public resolve(i: Import) {
+		const lp = [`<ImportManager.resolve>`, i.toString()]
+		L.d(...lp)
+
+		if (isRelativePath(i.from)) {
+			const pathToFile = resolve(i.sourceDir, i.from)
+
+			const tsPath = `${pathToFile}.ts`
+			const tsxPath = `${pathToFile}.tsx`
+
+			L.d(...lp, `trying if exists: ${tsPath}`)
+
+			if (existsSync(tsPath)) {
+				L.d(...lp, `"${tsPath}" path exists`)
+				return tsPath
+			}
+
+			if (existsSync(tsxPath)) {
+				L.d(...lp, `"${tsPath}" path exists`)
+				return tsxPath
+			}
+
+			throw new UnresolvedImportError(i)
+		} else {
+			// this is a library
+			// TODO node_modules
+			// TODO @types
+			throw new UnresolvedImportError(i)
+		}
+	}
+}
+
+function isRelativePath(s: string) {
+	return s.startsWith("../") || s.startsWith("./")
 }

src/utils/imports/model.ts

@@ -0,0 +1,44 @@
+import { parse } from "path"
+
+export class Import {
+	private _sourceDir: string | null = null
+
+	constructor(
+		/** the path of the file that contains the import declaration. */
+		public source: string,
+		/** the relative path to the target file of the import. */
+		public from: string,
+		/** the named exports (`import { named } from "./from"`). */
+		private named: Array<string>,
+		/** the default exports (`import default from "./from"`). */
+		private default_: string | null
+	) {}
+
+	public get sourceDir(): string {
+		if (!this._sourceDir) {
+			this._sourceDir = parse(this.source).dir
+		}
+		return this._sourceDir
+	}
+
+	/**
+	 * Checks if the {@link Import} contains a specific identifier.
+	 *
+	 * For example: `import Jon, { Doe } from "./helloworld"`
+	 *
+	 * Would result in:
+	 *
+	 * ```ts
+	 * containsIdentifier("Jon") // true
+	 * containsIdentifier("Doe") // true
+	 * containsIdentifier("helloworld") // false
+	 * ```
+	 */
+	public containsIdentifier(name: string) {
+		return this.default_ === name || this.named.includes(name)
+	}
+
+	public toString() {
+		return `import ${this.default_ ? `${this.default_} ` : ""}${this.named.length > 0 ? `{ ${this.named.join(", ")} }` : ""} from "${this.from}"`
+	}
+}

tests/configuration.test.ts

@@ -1,8 +1,8 @@
 import test from "ava"
 import { resolve } from "path"
-import { UnresolvedImportError } from "../src/models/Import"
 import { UnknownType } from "../src/models/UnknownType"
 import { Parser } from "../src/parser"
+import { UnresolvedImportError } from "../src/utils/imports/errors"
 
 test("breakOnUnresolvedImports: true", (t) => {
 	const parser = new Parser(resolve(__dirname, "fixtures", "configurationTestTypes.ts"), { breakOnUnresolvedImports: true })