Added support for filtering unused named imports.Uses the AST to check if named imports are used in the transpiled code. If not, filters out the import.This way non-emitting types will never be imported so we don't get the following error:[!] Error: '<Interface>' is not exported by <TypeScriptFile>.ts, imported by <SvelteFile>.svelte

Author: Maarten van Sambeek

src/transformers/typescript.ts

@@ -80,8 +80,112 @@ const importTransformer: ts.TransformerFactory<ts.SourceFile> = context => {
   return node => ts.visitNode(node, visit);
 };
 
+function findImportUsages(
+  node: ts.Node,
+  context: ts.TransformationContext,
+): { [name: string]: number } {
+  const usages: { [name: string]: number } = {};
+  let locals = new Set<string>();
+
+  const enterScope = <T>(action: () => T) => {
+    const parentLocals = locals;
+    locals = new Set([...locals]);
+    const result = action();
+    locals = parentLocals;
+    return result;
+  };
+
+  const findUsages: ts.Visitor = node => {
+    if (ts.isImportClause(node)) {
+      const bindings = node.namedBindings;
+
+      if (bindings && 'elements' in bindings) {
+        bindings.elements.forEach(
+          binding => (usages[binding.name.getText()] = 0),
+        );
+      }
+
+      return node;
+    }
+
+    if (ts.isFunctionDeclaration(node)) {
+      return enterScope(() => {
+        node.parameters
+          .map(p => p.name)
+          .filter(ts.isIdentifier)
+          .forEach(p => locals.add(p.getText()));
+        return ts.visitEachChild(node, child => findUsages(child), context);
+      });
+    }
+
+    if (ts.isBlock(node)) {
+      return enterScope(() =>
+        ts.visitEachChild(node, child => findUsages(child), context),
+      );
+    }
+
+    if (ts.isVariableDeclaration(node)) {
+      if (ts.isIdentifier(node.name)) {
+        locals.add(node.name.getText());
+      }
+    } else if (ts.isIdentifier(node)) {
+      const identifier = node.getText();
+      if (!locals.has(identifier) && usages[identifier] != undefined) {
+        usages[identifier]++;
+      }
+    }
+
+    return ts.visitEachChild(node, child => findUsages(child), context);
+  };
+
+  ts.visitNode(node, findUsages);
+
+  return usages;
+}
+
+const removeNonEmittingImports: ts.TransformerFactory<ts.SourceFile> = context => {
+  function createVisitor(usages: { [name: string]: number }) {
+    const visit: ts.Visitor = node => {
+      if (ts.isImportDeclaration(node)) {
+        let importClause = node.importClause;
+        const bindings = importClause.namedBindings;
+
+        if (bindings && ts.isNamedImports(bindings)) {
+          const namedImports = bindings.elements.filter(
+            element => usages[element.name.getText()] > 0,
+          );
+
+          if (namedImports.length !== bindings.elements.length) {
+            return ts.createImportDeclaration(
+              node.decorators,
+              node.modifiers,
+              namedImports.length == 0
+                ? undefined
+                : ts.createImportClause(
+                    importClause.name,
+                    ts.createNamedImports(namedImports)
+                  ),
+              node.moduleSpecifier,
+            );
+          }
+        }
+
+        return node;
+      }
+
+      return ts.visitEachChild(node, child => visit(child), context);
+    };
+
+    return visit;
+  }
+
+  return node =>
+    ts.visitNode(node, createVisitor(findImportUsages(node, context)));
+};
+
 const TS_TRANSFORMERS = {
   before: [importTransformer],
+  after: [removeNonEmittingImports],
 };
 
 const TS2552_REGEX = /Cannot find name '\$([a-zA-Z0-9_]+)'. Did you mean '([a-zA-Z0-9_]+)'\?/i;

test/fixtures/exports.ts

@@ -0,0 +1,6 @@
+export interface IFace {
+  readonly value: string;
+}
+
+export class ExportedClass {
+}

test/transformers/typescript.test.ts

@@ -31,6 +31,27 @@ describe('transformer - typescript', () => {
     'script.ts',
   )}</script>`;
 
+  it('should remove unused named imports', async () => {
+    const { code } = await transpile(
+      'import { IFace, ExportedClass } from "./fixtures/exports"',
+    );
+    expect(code).toBe('import "./fixtures/exports";\n');
+  });
+
+  it('should remove unused named imports but leave used ones', async () => {
+    const { code } = await transpile(
+      'import { IFace, ExportedClass } from "./fixtures/exports"\nnew ExportedClass()',
+    );
+    expect(code).toBe('import { ExportedClass } from "./fixtures/exports";\nnew ExportedClass();\n');
+  });
+
+  it('should remove unused named imports that conflict with local variables', async () => {
+    const { code } = await transpile(
+      'import { IFace as name } from "./fixtures/exports"\nexport let iface: name\nfunction func(name: string) { return name }',
+    );
+    expect(code).toBe('import "./fixtures/exports";\nexport let iface;\nfunction func(name) { return name; }\n');
+  });
+
   it('should disallow transpilation to es5 or lower', async () => {
     expect(
       transpile('export let foo = 10', { target: 'es3' }),
@@ -151,7 +172,7 @@ describe('transformer - typescript', () => {
       );
       expect(diagnostics.some(d => d.code === 2552)).toBe(false);
     });
-    
+
     it('should report a mismatched variable name error', async () => {
       const { diagnostics } = await transpile(
         `
@@ -161,6 +182,5 @@ describe('transformer - typescript', () => {
       );
       expect(diagnostics.some(d => d.code === 2552)).toBe(true);
     });
-
   });
 });