fix: fix remove extraneous import implementation

Author: haoqunjiang

generator/codemods/global-api/__testfixtures__/vue-use.input.js

@@ -1,6 +1,6 @@
 import Vue from 'vue'
 import VueRouter from 'vue-router'
-import Vuex from 'Vuex'
+import Vuex from 'vuex'
 
 Vue.use(VueRouter)
 Vue.use(Vuex)

generator/codemods/global-api/__testfixtures__/vue-use.output.js

@@ -1,3 +0,0 @@
-import 'vue';
-import 'vue-router';
-import 'Vuex';

generator/codemods/global-api/remove-trivial-root.js

@@ -2,7 +2,7 @@
  * It is expected to be run after the `createApp` transformataion
  * if a root component is trivial, that is, it contains only one simple prop,
  * like `{ render: h => h(App) }`, then just use the `App` variable
- * 
+ *
  * TODO: implement `remove-trivial-render`,
  * move all other rootProps to the second argument of `createApp`
  * @param {Object} context

generator/codemods/router/index.js

@@ -39,7 +39,9 @@ module.exports = function(fileInfo, api) {
           } else if (mode === 'abstract') {
             initializer = 'createMemoryHistory'
           } else {
-            console.error(`mode must be one of 'hash', 'history', or 'abstract'`)
+            console.error(
+              `mode must be one of 'hash', 'history', or 'abstract'`
+            )
             return p
           }
 

generator/codemods/utils/remove-extraneous-import.js

@@ -2,61 +2,78 @@
  * Note:
  * here we don't completely remove the import declaration statement
  * if all import specifiers are removed.
- * For example, `import Vue from 'vue'`,
- * if `Vue` is unused, the statement would become `import 'vue'`.
+ * For example, `import foo from 'bar'`,
+ * if `foo` is unused, the statement would become `import 'bar'`.
  * It is because we are not sure if the module contains any side effects.
  * @param {Object} context
  * @param {import('jscodeshift').JSCodeshift} context.j
  * @param {ReturnType<import('jscodeshift').Core>} context.root
  */
 module.exports = function removeExtraneousImport({ root, j }, name) {
-  const isPathEqual = (path1, path2) => {
-    return (
-      path1.node.start === path2.node.start && path1.node.end === path2.node.end
-    )
-  }
-  /**
-   * @param {import('jscodeshift').ASTPath} path
-   */
-  function filterAndRemoveImports(path) {
-    const usages = j(path)
-      .closestScope()
-      .find(j.Identifier, { name })
-      // Ignore the specifier
-      .filter(identifierPath => {
-        const parent = identifierPath.parent.node
-        return (
-          !j.ImportDefaultSpecifier.check(parent) &&
-          !j.ImportSpecifier.check(parent)
-        )
-      })
-      // Ignore properties in MemberExpressions
-      .filter(identifierPath => {
-        const parent = identifierPath.parent.node
-        return !(
-          j.MemberExpression.check(parent) &&
-          parent.property === identifierPath.node
-        )
-      })
+  const usages = root.find(j.Identifier, { name }).filter(identifierPath => {
+    const parent = identifierPath.parent.node
 
-    if (!usages.length) {
-      j(path).remove()
+    // Ignore the import specifier
+    if (
+      j.ImportDefaultSpecifier.check(parent) ||
+      j.ImportSpecifier.check(parent)
+    ) {
+      return false
     }
-  }
 
-  root
-    .find(j.ImportSpecifier, {
-      local: {
-        name
-      }
-    })
-    .filter(filterAndRemoveImports)
+    // Ignore properties in MemberExpressions
+    if (
+      j.MemberExpression.check(parent) &&
+      parent.property === identifierPath.node
+    ) {
+      return false
+    }
+
+    // Ignore keys in ObjectProperties
+    if (
+      j.ObjectProperty.check(parent) &&
+      parent.key === identifierPath.node &&
+      parent.value !== identifierPath.node
+    ) {
+      return false
+    }
+
+    return true
+  })
 
-  root
-    .find(j.ImportDefaultSpecifier, {
+  if (!usages.length) {
+    let specifier = root.find(j.ImportSpecifier, {
       local: {
         name
       }
     })
-    .filter(filterAndRemoveImports)
+    if (!specifier.length) {
+      specifier = root.find(j.ImportDefaultSpecifier, {
+        local: {
+          name
+        }
+      })
+    }
+
+    if (!specifier.length) {
+      return
+    }
+
+    const decl = specifier.closest(j.ImportDeclaration)
+    const declNode = decl.get(0).node
+    const peerSpecifiers = declNode.specifiers
+    const source = declNode.source.value
+
+    // these modules are known to have no side effects
+    const safelyRemovableModules = ['vue', 'vue-router', 'vuex']
+    if (
+      peerSpecifiers.length === 1 &&
+      safelyRemovableModules.includes(source)
+    ) {
+      decl.remove()
+    } else {
+      // otherwise, only remove the specifier
+      specifier.remove()
+    }
+  }
 }