Use the typescript transform to remove type imports

should fix sveltejs#153
use first param of emit to only emit for the actual source file

Author: halfnelson

src/transformers/typescript.ts

@@ -74,6 +74,9 @@ function isValidSvelteImportDiagnostic(filename: string, diagnostic: any) {
 const importTransformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
   const visit: ts.Visitor = (node) => {
     if (ts.isImportDeclaration(node)) {
+      if (node.importClause?.isTypeOnly) {
+        return ts.createEmptyStatement();
+      }
       return ts.createImportDeclaration(
         node.decorators,
         node.modifiers,
@@ -112,6 +115,72 @@ function isValidSvelteReactiveValueDiagnostic(
   return !(usedVar && proposedVar && usedVar === proposedVar);
 }
 
+function createImportTransformerFromProgram(program: ts.Program) {
+  const checker = program.getTypeChecker();
+
+  const importedTypeRemoverTransformer: ts.TransformerFactory<ts.SourceFile> = context => {
+    const visit: ts.Visitor = node => {
+      if (ts.isImportDeclaration(node)) {
+
+        let newImportClause: ts.ImportClause = node.importClause;
+
+        if (node.importClause) {
+          // import type {...} from './blah'
+          if (node.importClause?.isTypeOnly) {
+            return ts.createEmptyStatement();
+          }
+          
+          // import Blah, { blah } from './blah'
+          newImportClause = ts.getMutableClone(node.importClause);
+
+          // types can't be default exports, so we just worry about { blah } and { blah as name } exports
+          if (newImportClause.namedBindings && ts.isNamedImports(newImportClause.namedBindings)) {
+            let newBindings = ts.getMutableClone(newImportClause.namedBindings);
+            let newElements = [];
+
+            for (let spec of newBindings.elements) {
+              let ident = spec.name;
+              let symbol = checker.getSymbolAtLocation(ident);
+              let aliased = checker.getAliasedSymbol(symbol);
+              if (aliased) {
+                  if ((aliased.flags & (ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Interface)) > 0) {
+                     continue; //We found an imported type, don't add to our new import clause
+                  }
+              }
+              newElements.push(spec)
+            }
+
+            if (newElements.length > 0) {
+              newBindings.elements = ts.createNodeArray(newElements, newBindings.elements.hasTrailingComma);
+              newImportClause.namedBindings = newBindings;
+            } else {
+              newImportClause.namedBindings = undefined;
+            }
+          }
+
+          //we ended up removing all named bindings and we didn't have a name? nothing left to import.
+          if (!newImportClause.namedBindings && !newImportClause.name) {
+            return ts.createEmptyStatement();
+          }
+        }
+
+        return ts.createImportDeclaration(
+          node.decorators,
+          node.modifiers,
+          newImportClause,
+          node.moduleSpecifier,
+        );
+      }
+      return ts.visitEachChild(node, child => visit(child), context);
+    };
+
+    return node => ts.visitNode(node, visit);
+  };
+
+  return importedTypeRemoverTransformer;
+}
+
+
 function compileFileFromMemory(
   compilerOptions: CompilerOptions,
   { filename, content }: { filename: string; content: string },
@@ -172,12 +241,15 @@ function compileFileFromMemory(
   };
 
   const program = ts.createProgram([dummyFileName], compilerOptions, host);
+
+  let transformers = { before: [createImportTransformerFromProgram(program)] }
+
   const emitResult = program.emit(
+    program.getSourceFile(dummyFileName),
     undefined,
     undefined,
     undefined,
-    undefined,
-    TS_TRANSFORMERS,
+    transformers
   );
 
   // collect diagnostics without svelte import errors

test/fixtures/types.ts

@@ -0,0 +1,7 @@
+export type AType = "test1" | "test2"
+export interface AInterface {
+    test: string
+}
+export const AValue: string = "test"
+
+export default "String"

test/transformers/typescript.test.ts

@@ -175,5 +175,49 @@ describe('transformer - typescript', () => {
 
       expect(diagnostics.some((d) => d.code === 2552)).toBe(true);
     });
+
+    it('should remove imports containing types only', async () => {
+      const { code } = await transpile(
+        `
+          import { AType, AInterface } from './fixtures/types'
+          let name: AType = "test1";
+        `,
+      );
+
+      expect(code).not.toContain('/fixtures/types');
+    });
+
+    it('should remove type only imports', async () => {
+      const { code } = await transpile(
+        `
+          import type { AType, AInterface } from './fixtures/types'
+          let name: AType = "test1";
+        `,
+      );
+
+      expect(code).not.toContain('/fixtures/types');
+    });
+
+    it('should remove only the types from the imports', async () => {
+      const { code } = await transpile(
+        `
+          import { AValue, AType, AInterface } from './fixtures/types'
+          let name: AType = "test1";
+        `,
+      );
+
+      expect(code).toContain("import { AValue } from './fixtures/types'");
+    });
+
+    it('should remove the named imports completely if they were all types', async () => {
+      const { code } = await transpile(
+        `
+          import Default, { AType, AInterface } from './fixtures/types'
+          let name: AType = "test1";
+        `,
+      );
+
+      expect(code).toContain("import Default from './fixtures/types'");
+    });
   });
 });