[New] no extraneous type-only dependencies

package.json

@@ -71,7 +71,7 @@
     "cross-env": "^4.0.0",
     "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0",
     "eslint-import-resolver-node": "file:./resolvers/node",
-    "eslint-import-resolver-typescript": "^1.0.2 || ^1.1.1",
+    "eslint-import-resolver-typescript": "^1.0.2 || ^2.5.0",
     "eslint-import-resolver-webpack": "file:./resolvers/webpack",
     "eslint-import-test-order-redirect": "file:./tests/files/order-redirect",
     "eslint-module-utils": "file:./utils",

src/rules/no-extraneous-dependencies.js

@@ -117,6 +117,28 @@ function optDepErrorMessage(packageName) {
     `not optionalDependencies.`;
 }
 
+function resolveTypeOnly(modulePath, context) {
+  const sourceFile = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();
+  const configResolvers = context.settings['import/resolver'];
+  if (!configResolvers) {
+    return;
+  }
+
+  const resolvers = resolve.resolverReducer(configResolvers, new Map());
+  for (const [name, config] of resolvers) {
+    switch (name) {
+    case 'typescript':
+    case 'eslint-import-resolver-typescript': {
+      const resolver = resolve.requireResolver(name, sourceFile);
+      const resolved = resolver.resolve(modulePath, sourceFile, config);
+      if (resolved.found) {
+        return resolved.path;
+      }
+    }
+    }
+  }
+}
+
 function getModuleOriginalName(name) {
   const [first, second] = name.split('/');
   return first.startsWith('@') ? `${first}/${second}` : first;
@@ -160,23 +182,24 @@ function checkDependencyDeclaration(deps, packageName, declarationStatus) {
 
 function reportIfMissing(context, deps, depsOptions, node, name) {
   // Do not report when importing types
-  if (
-    node.importKind === 'type' ||
-    (node.parent && node.parent.importKind === 'type') ||
-    node.importKind === 'typeof'
-  ) {
+  if (node.importKind === 'typeof') {
     return;
   }
 
   if (importType(name, context) !== 'external') {
     return;
   }
 
-  const resolved = resolve(name, context);
+  const isTypeOnly = node.importKind === 'type';
+  const resolved = (isTypeOnly ? resolveTypeOnly : resolve)(name, context);
   if (!resolved) { return; }
 
-  const importPackageName = getModuleOriginalName(name);
-  let declarationStatus = checkDependencyDeclaration(deps, importPackageName);
+  // If this is type-only, only check realPackageName, because if you
+  // e.g. import type { JSONSchema7Type } from 'json-schema',
+  // realPackageName could be @types/json-schema but importPackageName
+  // will be json-schema and that package could be untyped.
+  const importPackageName = !isTypeOnly && getModuleOriginalName(name);
+  let declarationStatus = !isTypeOnly && checkDependencyDeclaration(deps, importPackageName);
 
   if (
     declarationStatus.isInDeps ||
@@ -196,7 +219,7 @@ function reportIfMissing(context, deps, depsOptions, node, name) {
 
     if (
       declarationStatus.isInDeps ||
-      (depsOptions.allowDevDeps && declarationStatus.isInDevDeps) ||
+      ((depsOptions.allowDevDeps || isTypeOnly) && declarationStatus.isInDevDeps) ||
       (depsOptions.allowPeerDeps && declarationStatus.isInPeerDeps) ||
       (depsOptions.allowOptDeps && declarationStatus.isInOptDeps) ||
       (depsOptions.allowBundledDeps && declarationStatus.isInBundledDeps)

tests/src/rules/no-extraneous-dependencies.js

@@ -392,12 +392,7 @@ describe('TypeScript', () => {
       };
 
       ruleTester.run('no-extraneous-dependencies', rule, {
-        valid: [
-          test(Object.assign({
-            code: 'import type T from "a";',
-            options: [{ packageDir: packageDirWithTypescriptDevDependencies, devDependencies: false }],
-          }, parserConfig)),
-        ],
+        valid: [],
         invalid: [
           test(Object.assign({
             code: 'import T from "a";',
@@ -406,6 +401,13 @@ describe('TypeScript', () => {
               message: "'a' should be listed in the project's dependencies, not devDependencies.",
             }],
           }, parserConfig)),
+          test(Object.assign({
+            code: 'import type T from "a";',
+            errors: [{
+              message: "'@types/a' should be listed in the project's dependencies. Run 'npm i -S @types/a' to add it",
+            }],
+            options: [{ packageDir: packageDirWithTypescriptDevDependencies, devDependencies: false }],
+          }, parserConfig)),
         ],
       });
     });

utils/resolve.js

@@ -235,4 +235,6 @@ function resolve(p, context) {
   }
 }
 resolve.relative = relative;
+resolve.resolverReducer = resolverReducer;
+resolve.requireResolver = requireResolver;
 exports.default = resolve;