extensions: added checkTypeImports option (#169)

Co-authored-by: SukkaW <isukkaw@gmail.com>

Author: teidesu

.changeset/tidy-crews-sit.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-import-x": minor
+---
+
+Add new rule option `checkTypedImports` for `extensions`, backports https://github.com/import-js/eslint-plugin-import/pull/2817

docs/rules/extensions.md

@@ -56,6 +56,8 @@ For example, `["error", "never", { "svg": "always" }]` would require that all ex
 In that case, if you still want to specify extensions, you can do so inside the **pattern** property.
 Default value of `ignorePackages` is `false`.
 
+By default, `import type` and `export type` style imports/exports are ignored. If you want to check them as well, you can set the `checkTypeImports` option to `true`.
+
 ### Exception
 
 When disallowing the use of certain extensions this rule makes an exception and allows the use of extension when the file would not be resolvable without extension.
@@ -104,6 +106,13 @@ import express from 'express/index'
 import * as path from 'path'
 ```
 
+The following patterns are considered problems when the configuration is set to "never" and the option "checkTypeImports" is set to `true`:
+
+```js
+import type { Foo } from './foo.ts';
+export type { Foo } from './foo.ts';
+```
+
 The following patterns are considered problems when configuration set to "always":
 
 ```js
@@ -166,6 +175,13 @@ import express from 'express'
 import foo from '@/foo'
 ```
 
+The following patterns are considered problems when the configuration is set to "always" and the option "checkTypeImports" is set to `true`:
+
+```js
+import type { Foo } from './foo';
+export type { Foo } from './foo';
+```
+
 ## When Not To Use It
 
 If you are not concerned about a consistent usage of file extension.

src/rules/extensions.ts

@@ -27,6 +27,9 @@ const properties = {
     ignorePackages: {
       type: 'boolean' as const,
     },
+    checkTypeImports: {
+      type: 'boolean' as const,
+    },
   },
 }
 
@@ -38,6 +41,7 @@ type NormalizedOptions = {
   defaultConfig?: DefaultConfig
   pattern?: Record<FileExtension, DefaultConfig>
   ignorePackages?: boolean
+  checkTypeImports?: boolean
 }
 
 type Options = DefaultConfig | NormalizedOptions
@@ -47,6 +51,7 @@ function buildProperties(context: RuleContext<MessageId, Options[]>) {
     defaultConfig: 'never',
     pattern: {},
     ignorePackages: false,
+    checkTypeImports: false,
   }
 
   for (const obj of context.options) {
@@ -57,7 +62,11 @@ function buildProperties(context: RuleContext<MessageId, Options[]>) {
     }
 
     // If this is not the new structure, transfer all props to result.pattern
-    if (obj.pattern === undefined && obj.ignorePackages === undefined) {
+    if (
+      obj.pattern === undefined &&
+      obj.ignorePackages === undefined &&
+      obj.checkTypeImports === undefined
+    ) {
       Object.assign(result.pattern, obj)
       continue
     }
@@ -71,6 +80,10 @@ function buildProperties(context: RuleContext<MessageId, Options[]>) {
     if (obj.ignorePackages !== undefined) {
       result.ignorePackages = obj.ignorePackages
     }
+
+    if (obj.checkTypeImports !== undefined) {
+      result.checkTypeImports = obj.checkTypeImports
+    }
   }
 
   if (result.defaultConfig === 'ignorePackages') {
@@ -213,8 +226,9 @@ export = createRule<Options[], MessageId>({
         if (!extension || !importPath.endsWith(`.${extension}`)) {
           // ignore type-only imports and exports
           if (
-            ('importKind' in node && node.importKind === 'type') ||
-            ('exportKind' in node && node.exportKind === 'type')
+            !props.checkTypeImports &&
+            (('importKind' in node && node.importKind === 'type') ||
+              ('exportKind' in node && node.exportKind === 'type'))
           ) {
             return
           }

test/rules/extensions.spec.ts

@@ -5,6 +5,15 @@ import { test, testFilePath } from '../utils'
 import rule from 'eslint-plugin-import-x/rules/extensions'
 
 const ruleTester = new TSESLintRuleTester()
+const ruleTesterWithTypeScriptImports = new TSESLintRuleTester({
+  settings: {
+    'import/resolver': {
+      typescript: {
+        alwaysTryTypes: true,
+      },
+    },
+  },
+})
 
 ruleTester.run('extensions', rule, {
   valid: [
@@ -694,6 +703,58 @@ describe('TypeScript', () => {
           { ts: 'never', tsx: 'never', js: 'never', jsx: 'never' },
         ],
       }),
+      test({
+        code: 'import type T from "./typescript-declare";',
+        errors: ['Missing file extension for "./typescript-declare"'],
+        options: [
+          'always',
+          {
+            ts: 'never',
+            tsx: 'never',
+            js: 'never',
+            jsx: 'never',
+            checkTypeImports: true,
+          },
+        ],
+      }),
+      test({
+        code: 'export type { MyType } from "./typescript-declare";',
+        errors: ['Missing file extension for "./typescript-declare"'],
+        options: [
+          'always',
+          {
+            ts: 'never',
+            tsx: 'never',
+            js: 'never',
+            jsx: 'never',
+            checkTypeImports: true,
+          },
+        ],
+      }),
+    ],
+  })
+  ruleTesterWithTypeScriptImports.run('extensions', rule, {
+    valid: [
+      test({
+        code: 'import type { MyType } from "./typescript-declare.ts";',
+        options: ['always', { checkTypeImports: true }],
+      }),
+      test({
+        code: 'export type { MyType } from "./typescript-declare.ts";',
+        options: ['always', { checkTypeImports: true }],
+      }),
+    ],
+    invalid: [
+      test({
+        code: 'import type { MyType } from "./typescript-declare";',
+        errors: ['Missing file extension for "./typescript-declare"'],
+        options: ['always', { checkTypeImports: true }],
+      }),
+      test({
+        code: 'export type { MyType } from "./typescript-declare";',
+        errors: ['Missing file extension for "./typescript-declare"'],
+        options: ['always', { checkTypeImports: true }],
+      }),
     ],
   })
 })