feat(dedupeImports): preserve imports with same from and name, but different type (#507)

8ctavio · web-flow · commit c340f3326e91 · 2026-04-13T10:04:27.000+09:00
* fix(dedupeImports): preserve imports array indexes

* test(dedupeImports): correctly dedupe imports when some are disabled

* perf(dedupeImports): use single map and for...of, and reduce iterations and lookups

* feat(dedupeImports): do not deduplicate complementary value and type imports

* test(dts): generate value and type declarations for complementary imports
diff --git a/src/utils.ts b/src/utils.ts
@@ -117,40 +117,74 @@ export function stringifyImports(imports: Import[], isCJS = false) {
     .join('\n')
 }
 
+function encodeImportName(name: string) {
+  return `\uFFFF${name}\uFFFE`
+}
+
 export function dedupeImports(imports: Import[], warn: (msg: string) => void) {
-  const map = new Map<string, number>()
-  const indexToRemove = new Set<number>()
+  const deduped = new Map<string | number, Import>()
 
-  imports.filter(i => !i.disabled).forEach((i, idx) => {
-    if (i.declarationType === 'enum' || i.declarationType === 'const enum' || i.declarationType === 'class')
-      return
+  for (let idx = imports.length - 1; idx >= 0; idx--) {
+    const currImp = imports[idx]
+    if (currImp.disabled || currImp.declarationType === 'enum' || currImp.declarationType === 'const enum' || currImp.declarationType === 'class') {
+      deduped.set(idx, currImp)
+      continue
+    }
 
-    const name = i.as ?? i.name
-    if (!map.has(name)) {
-      map.set(name, idx)
-      return
+    const name = String(currImp.as ?? currImp.name)
+    const prevImp = deduped.get(name)
+    if (!prevImp) {
+      deduped.set(name, currImp)
+      continue
     }
 
-    const other = imports[map.get(name)!]
+    const isSameSpecifier = (currImp.type || prevImp.type)
+      ? (currImp.typeFrom || currImp.from) === (prevImp.typeFrom || prevImp.from)
+      : currImp.from === prevImp.from
 
-    if (other.from === i.from) {
-      indexToRemove.add(idx)
-      return
+    if (isSameSpecifier) {
+      if (Boolean(currImp.type) === Boolean(prevImp.type)) {
+        // currImp and prevImp are the same import
+        if ((currImp.priority || 1) > (prevImp.priority || 1)) {
+          deduped.delete(name)
+          deduped.set(name, currImp)
+        }
+      }
+      else {
+        // currImp and prevImp are complementary imports; one for the value and one for the type
+        const altName = encodeImportName(name)
+        const prevImpComplement = deduped.get(altName)
+        if (!prevImpComplement) {
+          deduped.set(altName, currImp)
+        }
+        else if ((currImp.priority || 1) > (prevImpComplement.priority || 1)) {
+          deduped.delete(altName)
+          deduped.set(altName, currImp)
+        }
+      }
+      continue
     }
-    const diff = (other.priority || 1) - (i.priority || 1)
-    if (diff === 0)
-      warn(`Duplicated imports "${name}", the one from "${other.from}" has been ignored and "${i.from}" is used`)
 
-    if (diff <= 0) {
-      indexToRemove.add(map.get(name)!)
-      map.set(name, idx)
+    // currImp and prevImp are duplicate imports
+    const altName = encodeImportName(name)
+    const prevImpComplement = deduped.get(altName)
+    const priorityDiff = (currImp.priority || 1) - Math.max(prevImp.priority || 1, prevImpComplement?.priority || 1)
+    if (priorityDiff > 0) {
+      deduped.delete(name)
+      deduped.delete(altName)
+      deduped.set(name, currImp)
     }
-    else {
-      indexToRemove.add(idx)
+    else if (priorityDiff === 0) {
+      warn(`Duplicated imports "${name}", the one from "${currImp.from}" has been ignored and "${prevImp.from}" is used`)
     }
-  })
+  }
 
-  return imports.filter((_, idx) => !indexToRemove.has(idx))
+  let i = deduped.size
+  const dedupedImports = new Array(i) // eslint-disable-line unicorn/no-new-array
+  for (const imp of deduped.values()) {
+    dedupedImports[--i] = imp
+  }
+  return dedupedImports
 }
 
 export function toExports(imports: Import[], fileDir?: string, includeType = false, options: ToExportsOptions = {}) {
diff --git a/test/dedupe.test.ts b/test/dedupe.test.ts
@@ -67,6 +67,39 @@ describe('dedupeImports', () => {
     `)
   })
 
+  it('should not dedupe disabled imports', () => {
+    const imports = [
+      {
+        name: 'foo',
+        from: 'moduleA',
+        disabled: true,
+      },
+      {
+        name: 'foo',
+        from: 'moduleB',
+      },
+      {
+        name: 'foo',
+        from: 'moduleC',
+      },
+    ]
+
+    expect(dedupeImports(imports, warnFn)).toMatchInlineSnapshot(`
+      [
+        {
+          "disabled": true,
+          "from": "moduleA",
+          "name": "foo",
+        },
+        {
+          "from": "moduleC",
+          "name": "foo",
+        },
+      ]
+    `)
+    expect(warnMsg).toMatchInlineSnapshot(`"Duplicated imports "foo", the one from "moduleB" has been ignored and "moduleC" is used"`)
+  })
+
   it('should not warn about duplicates when one is disabled', () => {
     expect(dedupeImports(
       [
diff --git a/test/dts.test.ts b/test/dts.test.ts
@@ -146,3 +146,31 @@ it('should compat with `export =`', async () => {
     }"
   `)
 })
+
+it('should generate value and type declarations for complementary imports', async () => {
+  const { generateTypeDeclarations, init } = createUnimport({
+    imports: [{
+      name: 'Test',
+      from: 'module.js',
+    }, {
+      name: 'Test',
+      from: 'module.js',
+      type: true,
+    }],
+  })
+
+  await init()
+
+  await expect(generateTypeDeclarations()).resolves.toMatchInlineSnapshot(`
+    "export {}
+    declare global {
+      const Test: typeof import('module').Test
+    }
+    // for type re-export
+    declare global {
+      // @ts-ignore
+      export type { Test } from 'module'
+      import('module')
+    }"
+  `)
+})
