Merge pull request #4 from Rel1cx/tsl-module

Rel1cx · web-flow · commit 0d736397edd7 · 2026-01-06T23:39:31.000+08:00
Improve suggestions for duplicate exports and imports rules
diff --git a/packages/tsl-module/docs/README.md b/packages/tsl-module/docs/README.md
@@ -4,5 +4,5 @@
 
 | Variable | Description |
 | ------ | ------ |
-| [noDuplicateExports](variables/noDuplicateExports.md) | Rule to disallow duplicate exports from the same module. Combine multiple export statements from the same module into a single statement. |
-| [noDuplicateImports](variables/noDuplicateImports.md) | Rule to disallow duplicate imports from the same module. Combine multiple import statements from the same module into a single statement. |
+| [noDuplicateExports](variables/noDuplicateExports.md) | Rule to detect and merge duplicate `export from` statements from the same module. |
+| [noDuplicateImports](variables/noDuplicateImports.md) | Rule to detect and merge duplicate `import from` statements from the same module. |
diff --git a/packages/tsl-module/docs/variables/noDuplicateExports.md b/packages/tsl-module/docs/variables/noDuplicateExports.md
@@ -6,7 +6,7 @@
 const noDuplicateExports: (options?: "off") => Rule<unknown>;
 ```
 
-Rule to disallow duplicate exports from the same module. Combine multiple export statements from the same module into a single statement.
+Rule to detect and merge duplicate `export from` statements from the same module.
 
 ## Parameters
 
diff --git a/packages/tsl-module/docs/variables/noDuplicateImports.md b/packages/tsl-module/docs/variables/noDuplicateImports.md
@@ -6,7 +6,7 @@
 const noDuplicateImports: (options?: "off") => Rule<unknown>;
 ```
 
-Rule to disallow duplicate imports from the same module. Combine multiple import statements from the same module into a single statement.
+Rule to detect and merge duplicate `import from` statements from the same module.
 
 ## Parameters
 
diff --git a/packages/tsl-module/src/rules/no-duplicate-exports.test.ts b/packages/tsl-module/src/rules/no-duplicate-exports.test.ts
@@ -16,6 +16,12 @@ test("no-duplicate-exports", () => {
           {
             line: 2,
             message: messages.noDuplicateExports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate exports",
+                output: tsx`\nexport { A, B } from 'module';`,
+              },
+            ],
           },
         ],
       },
@@ -28,6 +34,12 @@ test("no-duplicate-exports", () => {
           {
             line: 2,
             message: messages.noDuplicateExports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate exports",
+                output: tsx`\nexport type { A, B } from 'module';`,
+              },
+            ],
           },
         ],
       },
diff --git a/packages/tsl-module/src/rules/no-duplicate-exports.ts b/packages/tsl-module/src/rules/no-duplicate-exports.ts
@@ -1,12 +1,18 @@
-import { defineRule } from "tsl";
+import { type AST, defineRule } from "tsl";
+import ts from "typescript";
 
 export const messages = {
-  noDuplicateExports: (p: { source: string }) =>
-    `Duplicate export to module ${p.source}. Combine into a single export statement.`,
+  noDuplicateExports: (p: { source: string }) => `Duplicate export from module ${p.source}.`,
 } as const;
 
+type ReExportDeclaration = AST.ExportDeclaration & { exportClause: {}; moduleSpecifier: {} };
+
+function isReExportDeclaration(node: AST.ExportDeclaration): node is ReExportDeclaration {
+  return node.exportClause != null && node.moduleSpecifier != null;
+}
+
 /**
- * Rule to disallow duplicate exports from the same module. Combine multiple export statements from the same module into a single statement.
+ * Rule to detect and merge duplicate `export from` statements from the same module.
  *
  * @todo Add autofix to merge duplicate exports automatically.
  *
@@ -40,26 +46,55 @@ export const messages = {
 export const noDuplicateExports = defineRule(() => {
   return {
     name: "module/no-duplicate-exports",
-    createData() {
-      return [
-        new Set<string>(), // for export
-        new Set<string>(), // for export type
-      ] as const;
+    createData(): { exports: ReExportDeclaration[] } {
+      return { exports: [] };
     },
     visitor: {
       ExportDeclaration(ctx, node) {
-        if (node.moduleSpecifier == null) return; // skip non-re-export exports
-        const exportSource = node.moduleSpecifier.getText();
-        const seen = ctx.data[node.isTypeOnly ? 1 : 0];
-        if (seen.has(exportSource)) {
+        if (!isReExportDeclaration(node)) return; // skip non-re-export exports
+        const source = node.moduleSpecifier.getText();
+        const duplicateExport = ctx.data.exports
+          .find((exp) => exp.isTypeOnly === node.isTypeOnly && exp.moduleSpecifier.getText() === source);
+        if (duplicateExport != null) {
           ctx.report({
             node,
-            message: messages.noDuplicateExports({ source: exportSource }),
+            message: messages.noDuplicateExports({ source }),
+            suggestions: buildSuggestions(duplicateExport, node),
           });
           return;
         }
-        seen.add(exportSource);
+        ctx.data.exports.push(node);
       },
     },
   };
 });
+
+function buildSuggestions(a: ReExportDeclaration, b: ReExportDeclaration) {
+  switch (true) {
+    case ts.isNamedExports(a.exportClause)
+      && ts.isNamedExports(b.exportClause): {
+      const aElements = a.exportClause.elements.map((el) => el.getText());
+      const bElements = b.exportClause.elements.map((el) => el.getText());
+      const parts = Array.from(new Set([...aElements, ...bElements])).sort();
+      return [
+        {
+          message: "Merge duplicate exports",
+          changes: [
+            {
+              node: a,
+              newText: "",
+            },
+            {
+              node: b,
+              // dprint-ignore
+              newText: `export ${a.isTypeOnly ? "type " : ""}{ ${parts.join(", ")} } from ${a.moduleSpecifier.getText()};`,
+            },
+          ],
+        },
+      ];
+    }
+    // TODO: handle other exportClause kinds if needed
+    default:
+      return [];
+  }
+}
diff --git a/packages/tsl-module/src/rules/no-duplicate-imports.test.ts b/packages/tsl-module/src/rules/no-duplicate-imports.test.ts
@@ -16,6 +16,14 @@ test("no-duplicate-import", () => {
           {
             line: 2,
             message: messages.noDuplicateImports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                output: tsx`
+                  import { A, B } from 'module';\n
+                `,
+              },
+            ],
           },
         ],
       },
@@ -28,6 +36,14 @@ test("no-duplicate-import", () => {
           {
             line: 2,
             message: messages.noDuplicateImports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                output: tsx`
+                  import type { A, B } from 'module';\n
+                `,
+              },
+            ],
           },
         ],
       },
@@ -40,6 +56,49 @@ test("no-duplicate-import", () => {
           {
             line: 2,
             message: messages.noDuplicateImports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                output: tsx`
+                  import defer { foo } from 'module';\n
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        code: tsx`
+          import foo, { type bar, baz } from 'module';
+          import foo2, { type qux, quux } from 'module';
+          import foo3, { corge } from 'module';
+        `,
+        errors: [
+          {
+            line: 2,
+            message: messages.noDuplicateImports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                output: tsx`
+                  import foo, { type bar, baz, type qux, quux } from 'module';\n
+                  import foo3, { corge } from 'module';
+                `,
+              },
+            ],
+          },
+          {
+            line: 3,
+            message: messages.noDuplicateImports({ source: "'module'" }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                output: tsx`
+                  import foo, { type bar, baz, corge } from 'module';
+                  import foo2, { type qux, quux } from 'module';\n
+                `,
+              },
+            ],
           },
         ],
       },
diff --git a/packages/tsl-module/src/rules/no-duplicate-imports.ts b/packages/tsl-module/src/rules/no-duplicate-imports.ts
@@ -1,15 +1,25 @@
-import type { unit } from "@let/eff";
+import { unit } from "@let/eff";
 import { P, match } from "ts-pattern";
-import { defineRule } from "tsl";
+import { type AST, defineRule } from "tsl";
 import ts from "typescript";
 
 export const messages = {
-  noDuplicateImports: (p: { source: string }) =>
-    `Duplicate import from module ${p.source}. Combine into a single import statement.`,
+  noDuplicateImports: (p: { source: string }) => `Duplicate import from module ${p.source}.`,
 } as const;
 
+type ImportKind = 0 | 1 | 2; // 0: import, 1: import type, 2: import defer
+
+interface ImportInfo {
+  node: AST.ImportDeclaration;
+  kind: ImportKind;
+  defaultImport: string | unit;
+  namedImports: string[];
+  namespaceImport: string | unit;
+  source: string;
+}
+
 /**
- * Rule to disallow duplicate imports from the same module. Combine multiple import statements from the same module into a single statement.
+ * Rule to detect and merge duplicate `import from` statements from the same module.
  *
  * @todo Add autofix to merge duplicate imports automatically.
  *
@@ -43,33 +53,96 @@ export const messages = {
 export const noDuplicateImports = defineRule(() => {
   return {
     name: "module/no-duplicate-imports",
-    createData() {
-      return [
-        new Set<string>(), // for import
-        new Set<string>(), // for import type
-        new Set<string>(), // for import defer
-      ] as const;
+    createData(): { imports: [ImportInfo[], ImportInfo[], ImportInfo[]] } {
+      return { imports: [[], [], []] };
     },
     visitor: {
       ImportDeclaration(ctx, node) {
         if (node.importClause == null) return; // skip side-effect imports
+        const importKind = getImportKind(node);
         const importSource = node.moduleSpecifier.getText();
-        const seen = ctx.data[
-          match<ts.ImportPhaseModifierSyntaxKind | unit, 0 | 1 | 2>(node.importClause.phaseModifier)
-            .with(P.nullish, () => 0)
-            .with(ts.SyntaxKind.TypeKeyword, () => 1)
-            .with(ts.SyntaxKind.DeferKeyword, () => 2)
-            .otherwise(() => 0)
-        ];
-        if (seen.has(importSource)) {
+        const importInfo = {
+          node,
+          source: importSource,
+          kind: importKind,
+          ...decodeImportClause(node.importClause),
+        } as const satisfies ImportInfo;
+        const existingImports = ctx.data.imports[importKind];
+        const duplicateImport = existingImports.find((imp) => imp.source === importInfo.source);
+        if (duplicateImport != null) {
           ctx.report({
             node,
-            message: messages.noDuplicateImports({ source: importSource }),
+            message: messages.noDuplicateImports({ source: importInfo.source }),
+            suggestions: [
+              {
+                message: "Merge duplicate imports",
+                changes: [
+                  {
+                    node,
+                    newText: "",
+                  },
+                  {
+                    node: duplicateImport.node,
+                    newText: buildMergedImport(duplicateImport, importInfo),
+                  },
+                ],
+              },
+            ],
           });
           return;
         }
-        seen.add(importSource);
+        existingImports.push(importInfo);
       },
     },
   };
 });
+
+function getImportKind(node: AST.ImportDeclaration): ImportKind {
+  return match<ts.ImportPhaseModifierSyntaxKind | unit, ImportKind>(node.importClause?.phaseModifier)
+    .with(P.nullish, () => 0)
+    .with(ts.SyntaxKind.TypeKeyword, () => 1)
+    .with(ts.SyntaxKind.DeferKeyword, () => 2)
+    .otherwise(() => 0);
+}
+
+function decodeImportClause(node: AST.ImportClause) {
+  const { name, namedBindings } = node;
+  return {
+    defaultImport: name?.getText(),
+    namedImports: namedBindings != null
+        && ts.isNamedImports(namedBindings)
+      ? namedBindings.elements.map((el) => el.getText())
+      : [],
+    namespaceImport: namedBindings != null
+        && ts.isNamespaceImport(namedBindings)
+      ? namedBindings.name.getText()
+      : unit,
+  } as const;
+}
+
+function buildMergedImport(a: ImportInfo, b: ImportInfo): string {
+  const parts: string[] = [];
+  // Default import
+  if (a.defaultImport != null) {
+    parts.push(a.defaultImport);
+  } else if (b.defaultImport != null) {
+    parts.push(b.defaultImport);
+  }
+  // Namespace import
+  if (a.namespaceImport != null) {
+    parts.push(`* as ${a.namespaceImport}`);
+  } else if (b.namespaceImport != null) {
+    parts.push(`* as ${b.namespaceImport}`);
+  }
+  // Named imports
+  const namedImports = Array.from(new Set([...a.namedImports, ...b.namedImports]));
+  if (namedImports.length > 0) {
+    parts.push(`{ ${namedImports.join(", ")} }`);
+  }
+  const importKindPrefix = match<ImportKind, string>(a.kind)
+    .with(0, () => "import")
+    .with(1, () => "import type")
+    .with(2, () => "import defer")
+    .exhaustive();
+  return `${importKindPrefix} ${parts.join(", ")} from ${a.source};`;
+}
