fix: prevent removing JSX type parameter imports (#43)

Author: kcmr

__tests__/__snapshots__/transform.spec.js.snap

@@ -18,6 +18,17 @@ exports[`does not remove parameter decorators 1`] = `
   "
 `;
 
+exports[`preserves imports of JSX type parameters 1`] = `
+"
+  import { SomeComponent } from './some-path';  
+  import { SomeType } from './another-path';
+
+  const App = () => {
+    return <SomeComponent<SomeType> />;
+  };
+  "
+`;
+
 exports[`preserves specified import identifiers 1`] = `
 "
   import { React, useState } from 'react';

__tests__/transform.spec.js

@@ -135,6 +135,18 @@ it('preserves specified import identifiers', () => {
   };
   `;
 
-  expect(() => transform(code, ['React'])).not.toThrow();
   expect(transform(code, ['React'])).toMatchSnapshot();
 });
+
+it('preserves imports of JSX type parameters', () => {
+  const code = `
+  import { SomeComponent } from './some-path';  
+  import { SomeType } from './another-path';
+
+  const App = () => {
+    return <SomeComponent<SomeType> />;
+  };
+  `;
+
+  expect(transform(code)).toMatchSnapshot();
+});

src/plugin.ts

@@ -5,7 +5,26 @@ type ImportSpecifier =
   | types.ImportNamespaceSpecifier
   | types.ImportSpecifier;
 
-const decorators = new Set();
+class ImportTracker {
+  private decorators = new Set<string>();
+  private typeParameters = new Set<string>();
+
+  addDecorator(name: string) {
+    this.decorators.add(name);
+  }
+
+  addTypeParameter(name: string) {
+    this.typeParameters.add(name);
+  }
+
+  shouldPreserve(name: string, userPreserved?: string[]) {
+    return (
+      this.decorators.has(name) ||
+      this.typeParameters.has(name) ||
+      userPreserved?.includes(name)
+    );
+  }
+}
 
 function isUnusedImportSpecifier(path: NodePath<ImportSpecifier>) {
   return !path.scope.bindings[path.node.local.name].referenced;
@@ -15,36 +34,61 @@ function hasAllSpecifiersRemoved(path: NodePath<types.ImportDeclaration>) {
   return path.get('specifiers').length === 0;
 }
 
-function collectParameterDecorators(path: NodePath<types.TSParameterProperty>) {
+function collectParameterDecorators(
+  path: NodePath<types.TSParameterProperty>,
+  tracker: ImportTracker,
+) {
   path.node.decorators?.forEach(({ expression }) => {
     if (expression.type !== 'CallExpression') return;
 
     if (expression.callee.type === 'Identifier') {
-      decorators.add(expression.callee.name);
+      tracker.addDecorator(expression.callee.name);
     }
 
     expression.arguments.forEach((arg) => {
       if (arg.type === 'Identifier') {
-        decorators.add(arg.name);
+        tracker.addDecorator(arg.name);
       }
     });
   });
 }
 
+function collectJSXTypeParameters(
+  path: NodePath<types.JSXElement>,
+  tracker: ImportTracker,
+) {
+  const openingElement = path.node.openingElement;
+  if (openingElement.typeParameters) {
+    openingElement.typeParameters.params.forEach((param) => {
+      if (
+        param.type === 'TSTypeReference' &&
+        param.typeName.type === 'Identifier'
+      ) {
+        tracker.addTypeParameter(param.typeName.name);
+      }
+    });
+  }
+}
+
 export function removeUnusedImports(preserve?: string[]): PluginObj {
+  const tracker = new ImportTracker();
+
   return {
     visitor: {
       Program(path: NodePath<types.Program>) {
         path.traverse({
           TSParameterProperty(path: NodePath<types.TSParameterProperty>) {
-            collectParameterDecorators(path);
+            collectParameterDecorators(path, tracker);
+          },
+          JSXElement(path: NodePath<types.JSXElement>) {
+            collectJSXTypeParameters(path, tracker);
           },
         });
       },
       ImportDeclaration(path: NodePath<types.ImportDeclaration>) {
         path.get('specifiers').forEach((specifier) => {
-          if (decorators.has(specifier.node.local.name)) return;
-          if (preserve?.includes(specifier.node.local.name)) return;
+          const localName = specifier.node.local.name;
+          if (tracker.shouldPreserve(localName, preserve)) return;
 
           isUnusedImportSpecifier(specifier) && specifier.remove();
           hasAllSpecifiersRemoved(path) && path.remove();