FIXED: dynamic type imports

src/index.ts

@@ -1,5 +1,5 @@
 import { dirname, relative, resolve, extname } from "path";
-import ts from "typescript";
+import ts, { LiteralTypeNode } from "typescript";
 import slash from "slash";
 import { parse } from "url";
 import { existsSync } from "fs";
@@ -109,19 +109,51 @@ const transformer = (_: ts.Program) => (context: ts.TransformationContext) => (
         fileLiteral
       ]);
     }
+
     if (ts.isExternalModuleReference(node)) {
       return unpathImportEqualsDeclaration(node);
     }
+
     if (ts.isImportDeclaration(node)) {
       return unpathImportDeclaration(node);
     }
+
     if (ts.isExportDeclaration(node)) {
       return unpathExportDeclaration(node);
     }
 
+    if (ts.isImportTypeNode(node)) {
+      return unpathImportTypeNode(node);
+    }
+
     return ts.visitEachChild(node, visit, context);
   }
 
+  function unpathImportTypeNode(node: ts.ImportTypeNode) {
+    const argument = node.argument as LiteralTypeNode;
+
+    if (!ts.isStringLiteral(argument.literal)) {
+      return node;
+    }
+
+    const file = bindModuleToFile(argument.literal.text);
+
+    if (!file) {
+      return node;
+    }
+
+    const fileLiteral = ts.createLiteral(file);
+    const fileArgument = ts.updateLiteralTypeNode(argument, fileLiteral);
+
+    return ts.updateImportTypeNode(
+      node,
+      fileArgument,
+      node.qualifier,
+      node.typeArguments,
+      node.isTypeOf
+    );
+  }
+
   function unpathImportEqualsDeclaration(node: ts.ExternalModuleReference) {
     if (!ts.isStringLiteral(node.expression)) {
       return node;

tests/__fixtures/with-path/core/index.ts

@@ -8,6 +8,10 @@ import * as path from "path";
 import * as b from "circular/a";
 import * as c from "../circular/a";
 import { myNative } from "@utils/utils.native";
+import { Logger } from "@dynamic/logger";
+import { LogLevel } from "@dynamic/logger-types";
+
+type LoggerManager = import("@dynamic/manager").LoggerManager;
 
 c.A;
 b.A;
@@ -20,3 +24,17 @@ const n: NoRuntimecodeHere = null as any;
 
 subs(2, 3);
 const a = new A("");
+
+const manager: LoggerManager = {
+  loggers: [
+    new Logger(),
+    new Logger(),
+  ]
+};
+
+manager.loggers.forEach((logger) => {
+  logger.log({
+    level: LogLevel.DEBUG,
+    text: 'test',
+  })
+})

tests/__fixtures/with-path/dynamic/logger-types.ts

@@ -0,0 +1,9 @@
+export enum LogLevel {
+  DEBUG = 1,
+  INFO = 2,
+}
+
+export interface Log {
+  level: LogLevel;
+  text: string;
+}

tests/__fixtures/with-path/dynamic/logger.ts

@@ -0,0 +1,10 @@
+type Log = import("@dynamic/logger-types").Log;
+type LogLevel = import("@dynamic/logger-types").LogLevel;
+
+export class Logger {
+  level: LogLevel;
+
+  public log (x: Log): void {
+    console.log(x);
+  };
+}

tests/__fixtures/with-path/dynamic/manager.ts

@@ -0,0 +1,5 @@
+type Logger = import("@dynamic/logger").Logger;
+
+export interface LoggerManager {
+  loggers: Array<Logger>;
+}