Add dependencies for import types

src/lib/module-info.ts

@@ -265,35 +265,43 @@ function findReferencedFiles(src: ts.SourceFile, packageName: string, subDirecto
  * All strings referenced in `import` statements.
  * Does *not* include <reference> directives.
  */
-function* imports({ statements }: ts.SourceFile | ts.ModuleBlock): Iterable<string> {
-    for (const node of statements) {
+function imports(sourceFile: ts.SourceFile): Iterable<string> {
+    const result: string[] = [];
+    ts.forEachChild(sourceFile, recur);
+    return result;
+
+    function recur(node: ts.Node) {
         switch (node.kind) {
             case ts.SyntaxKind.ImportDeclaration:
             case ts.SyntaxKind.ExportDeclaration: {
                 const { moduleSpecifier } = node as ts.ImportDeclaration | ts.ExportDeclaration;
                 if (moduleSpecifier && moduleSpecifier.kind === ts.SyntaxKind.StringLiteral) {
-                    yield (moduleSpecifier as ts.StringLiteral).text;
+                    result.push((moduleSpecifier as ts.StringLiteral).text);
                 }
                 break;
             }
 
             case ts.SyntaxKind.ImportEqualsDeclaration: {
                 const { moduleReference } = node as ts.ImportEqualsDeclaration;
                 if (moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
-                    yield parseRequire(moduleReference);
+                    result.push(parseRequire(moduleReference));
                 }
                 break;
             }
 
-            case ts.SyntaxKind.ModuleDeclaration: {
-                const { name, body } = node as ts.ModuleDeclaration;
-                if (name.kind === ts.SyntaxKind.StringLiteral && body) {
-                    yield* imports(body as ts.ModuleBlock);
+            case ts.SyntaxKind.ImportType: {
+                const { argument } = node as ts.ImportTypeNode;
+                if (argument.kind === ts.SyntaxKind.LiteralType) {
+                    const { literal } = argument as ts.LiteralTypeNode;
+                    if (literal.kind === ts.SyntaxKind.StringLiteral) {
+                        result.push(literal.text);
+                    }
                 }
                 break;
             }
 
             default:
+                ts.forEachChild(node, recur);
         }
     }
 }