feat: add allowSeparateTypeImports option to no-duplicate-imports (#19872)

* feat: add allowSeparateTypeImports option to no-duplicate-imports

* fix CI

* clarify docs

Author: sethamus

docs/src/rules/no-duplicate-imports.md

@@ -61,7 +61,12 @@ import * as something from 'module';
 
 ## Options
 
-This rule takes one optional argument, an object with a single key, `includeExports` which is a `boolean`. It defaults to `false`.
+This rule has an object option:
+
+* `"includeExports"`: `true` (default `false`) checks for exports in addition to imports.
+* `"allowSeparateTypeImports"`: `true` (default `false`) allows a type import alongside a value import from the same module in TypeScript files.
+
+### includeExports
 
 If re-exporting from an imported module, you should add the imports to the `import`-statement, and export that directly, not use `export ... from`.
 
@@ -110,3 +115,59 @@ export * from 'module';
 ```
 
 :::
+
+### allowSeparateTypeImports
+
+TypeScript allows importing types using `import type`. By default, this rule flags instances of `import type` that have the same specifier as `import`. The `allowSeparateTypeImports` option allows you to override this behavior.
+
+Example of **incorrect** TypeScript code for this rule with the default `{ "allowSeparateTypeImports": false }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-duplicate-imports: ["error", { "allowSeparateTypeImports": false }]*/
+
+import { someValue } from 'module';
+import type { SomeType } from 'module';
+```
+
+:::
+
+Example of **correct** TypeScript code for this rule with the default `{ "allowSeparateTypeImports": false }` option:
+
+::: correct
+
+```ts
+/*eslint no-duplicate-imports: ["error", { "allowSeparateTypeImports": false }]*/
+
+import { someValue, type SomeType } from 'module';
+```
+
+:::
+
+Example of **incorrect** TypeScript code for this rule with the `{ "allowSeparateTypeImports": true }` option:
+
+::: incorrect
+
+```ts
+/*eslint no-duplicate-imports: ["error", { "allowSeparateTypeImports": true }]*/
+
+import { someValue } from 'module';
+import type { SomeType } from 'module';
+import type { AnotherType } from 'module';
+```
+
+:::
+
+Example of **correct** TypeScript code for this rule with the `{ "allowSeparateTypeImports": true }` option:
+
+::: correct
+
+```ts
+/*eslint no-duplicate-imports: ["error", { "allowSeparateTypeImports": true }]*/
+
+import { someValue } from 'module';
+import type { SomeType, AnotherType } from 'module';
+```
+
+:::

lib/rules/no-duplicate-imports.js

@@ -91,13 +91,33 @@ function isImportExportCanBeMerged(node1, node2) {
  * Returns a boolean if we should report (import|export).
  * @param {ASTNode} node A node to be reported or not.
  * @param {[ASTNode]} previousNodes An array contains previous nodes of the module imported or exported.
+ * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
  * @returns {boolean} True if the (import|export) should be reported.
  */
-function shouldReportImportExport(node, previousNodes) {
+function shouldReportImportExport(
+	node,
+	previousNodes,
+	allowSeparateTypeImports,
+) {
 	let i = 0;
 
 	while (i < previousNodes.length) {
-		if (isImportExportCanBeMerged(node, previousNodes[i])) {
+		const previousNode = previousNodes[i];
+
+		if (allowSeparateTypeImports) {
+			const isTypeNode =
+				node.importKind === "type" || node.exportKind === "type";
+			const isTypePrevious =
+				previousNode.importKind === "type" ||
+				previousNode.exportKind === "type";
+
+			if (isTypeNode !== isTypePrevious) {
+				i++;
+				continue;
+			}
+		}
+
+		if (isImportExportCanBeMerged(node, previousNode)) {
 			return true;
 		}
 		i++;
@@ -136,6 +156,7 @@ function getModule(node) {
  * @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type.
  * @param {string} declarationType A declaration type can be an import or export.
  * @param {boolean} includeExports Whether or not to check for exports in addition to imports.
+ * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
  * @returns {void} No return value.
  */
 function checkAndReport(
@@ -144,6 +165,7 @@ function checkAndReport(
 	modules,
 	declarationType,
 	includeExports,
+	allowSeparateTypeImports,
 ) {
 	const module = getModule(node);
 
@@ -157,19 +179,43 @@ function checkAndReport(
 			exportNodes = getNodesByDeclarationType(previousNodes, "export");
 		}
 		if (declarationType === "import") {
-			if (shouldReportImportExport(node, importNodes)) {
+			if (
+				shouldReportImportExport(
+					node,
+					importNodes,
+					allowSeparateTypeImports,
+				)
+			) {
 				messagesIds.push("import");
 			}
 			if (includeExports) {
-				if (shouldReportImportExport(node, exportNodes)) {
+				if (
+					shouldReportImportExport(
+						node,
+						exportNodes,
+						allowSeparateTypeImports,
+					)
+				) {
 					messagesIds.push("importAs");
 				}
 			}
 		} else if (declarationType === "export") {
-			if (shouldReportImportExport(node, exportNodes)) {
+			if (
+				shouldReportImportExport(
+					node,
+					exportNodes,
+					allowSeparateTypeImports,
+				)
+			) {
 				messagesIds.push("export");
 			}
-			if (shouldReportImportExport(node, importNodes)) {
+			if (
+				shouldReportImportExport(
+					node,
+					importNodes,
+					allowSeparateTypeImports,
+				)
+			) {
 				messagesIds.push("exportAs");
 			}
 		}
@@ -196,13 +242,15 @@ function checkAndReport(
  * @param {Map} modules A Map object contains as a key a module name and as value an array contains objects, each object contains a node and a declaration type.
  * @param {string} declarationType A declaration type can be an import or export.
  * @param {boolean} includeExports Whether or not to check for exports in addition to imports.
+ * @param {boolean} allowSeparateTypeImports Whether to allow separate type and value imports.
  * @returns {nodeCallback} A function passed to ESLint to handle the statement.
  */
 function handleImportsExports(
 	context,
 	modules,
 	declarationType,
 	includeExports,
+	allowSeparateTypeImports,
 ) {
 	return function (node) {
 		const module = getModule(node);
@@ -214,6 +262,7 @@ function handleImportsExports(
 				modules,
 				declarationType,
 				includeExports,
+				allowSeparateTypeImports,
 			);
 			const currentNode = { node, declarationType };
 			let nodes = [currentNode];
@@ -231,11 +280,14 @@ function handleImportsExports(
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "problem",
 
 		defaultOptions: [
 			{
 				includeExports: false,
+				allowSeparateTypeImports: false,
 			},
 		],
 
@@ -252,6 +304,9 @@ module.exports = {
 					includeExports: {
 						type: "boolean",
 					},
+					allowSeparateTypeImports: {
+						type: "boolean",
+					},
 				},
 				additionalProperties: false,
 			},
@@ -266,14 +321,15 @@ module.exports = {
 	},
 
 	create(context) {
-		const [{ includeExports }] = context.options;
+		const [{ includeExports, allowSeparateTypeImports }] = context.options;
 		const modules = new Map();
 		const handlers = {
 			ImportDeclaration: handleImportsExports(
 				context,
 				modules,
 				"import",
 				includeExports,
+				allowSeparateTypeImports,
 			),
 		};
 
@@ -283,12 +339,14 @@ module.exports = {
 				modules,
 				"export",
 				includeExports,
+				allowSeparateTypeImports,
 			);
 			handlers.ExportAllDeclaration = handleImportsExports(
 				context,
 				modules,
 				"export",
 				includeExports,
+				allowSeparateTypeImports,
 			);
 		}
 		return handlers;

lib/types/rules.d.ts

@@ -2292,6 +2292,10 @@ export interface ESLintRules extends Linter.RulesRecord {
 				 * @default false
 				 */
 				includeExports: boolean;
+				/**
+				 * @default false
+				 */
+				allowSeparateTypeImports: boolean;
 			}>,
 		]
 	>;