next

packages/core/src/analyze-import.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-continue */
 import type MagicString from 'magic-string';
 import type { ResolveFn } from 'vite';
 import { normalizePath } from 'vite';
@@ -76,7 +77,7 @@ async function getImportsMap(
  */
 const formatImportReplacement = ({ name, alias, originalName, importDefault }: ImportInput) => {
   if (importDefault) return `default as ${alias ?? originalName ?? name}`;
-  if (originalName) return `${originalName}${alias ? ` as ${alias}` : ` as ${name}`}`;
+  if (originalName) return `${originalName} as ${alias ?? name}`;
   return `${name}${alias ? ` as ${alias}` : ''}`;
 };
 
@@ -148,18 +149,29 @@ const resolveImportedCircularEntities = async (
   resolver: ResolveFn,
   path: string,
 ) => {
-  const output: ImportStatement[] = [];
+  const entityMap = new Map<string, string[]>();
   const originalEntry = entries.get(path)!;
   for (const entity of imported) {
-    const { originalName } = entity;
+    const { originalName, alias } = entity;
     if (originalName && originalEntry.exports.has(originalName)) {
       const originalImport = originalEntry.exports.get(originalName)!;
       const resolvedPath = await resolver(originalImport.path, path);
-      const resolvedImports = methods.formatImportReplacement(entity);
-      output.push(`import { ${resolvedImports} } from '${resolvedPath}'`);
+      if (!resolvedPath) continue;
+
+      const resolvedImports = methods.formatImportReplacement({
+        ...originalImport,
+        name: originalName,
+        alias,
+      });
+
+      entityMap.set(resolvedPath, [...(entityMap.get(resolvedPath) ?? []), resolvedImports]);
     }
   }
-  return output;
+
+  const imports = [...entityMap.entries()];
+  return imports.map(
+    ([p, ents]) => `import { ${ents.join(', ')} } from '${p}'`,
+  ) as ImportStatement[];
 };
 
 /**
@@ -187,6 +199,7 @@ const analyzeImportStatement = async (
   if (isWildCardImport) return;
 
   const imports = methods.getImportedEntryExports(code, startPosition, endPosition);
+
   const imported = await methods.getImportsMap(entryExports, entryPath, imports, resolver);
   const replacement = await methods.getImportReplacements(imported, entryPath, entries, resolver);
   src.overwrite(startPosition, endPosition + 1, `${replacement.join(';\n')};`);

packages/core/tests/__mocks__/unit/entry-b/module.ts

@@ -0,0 +1 @@
+export const SomeName = 'some-name';

packages/core/tests/__mocks__/unit/entry-c/Reexport.ts

@@ -1,4 +1,4 @@
 export {
   A_MODULE_E,
   A_MODULE_A as AA,
-} from '@mocks/entry-a';
+} from '@mocks/unit/entry-a';

packages/core/tests/analyze-import.test.ts

@@ -12,7 +12,6 @@ import {
   MOCKS_FOLDER_UNIT,
   resolveUnitEntry,
   STUB_PATH,
-  STUB_SOURCE,
 } from './utils';
 import type { EntryData, ImportInput, PluginEntries, TargetImports } from '../src/types';
 
@@ -303,27 +302,6 @@ describe('resolveImportedEntities', () => {
   });
 });
 
-describe('resolveImportedCircularEntities', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  const entryPath = 'entryB';
-  const entryData: EntryData = {
-    exports: new Map([[MOCK_IMPORT_INPUT.name, MOCK_IMPORT_INPUT]]),
-    source: STUB_SOURCE,
-    updatedSource: STUB_SOURCE,
-  };
-
-  const imported: ImportInput[] = [MOCK_IMPORT_INPUT];
-  const entries: PluginEntries = new Map([[entryPath, entryData]]);
-
-  it('should call "formatImportReplacement" with resolved entry data', async () => {
-    await ImportAnalyzer.resolveImportedCircularEntities(imported, entries, resolver, entryPath);
-    expect(ImportAnalyzer.formatImportReplacement).toHaveBeenCalledTimes(imported.length);
-  });
-});
-
 describe('analyzeImportStatement', () => {
   it('should ignore wildcard import statements', async () => {
     vi.restoreAllMocks();

packages/core/tests/cases/cross-entries/default-export-has-default-export.ts

@@ -0,0 +1 @@
+export default "Some default export"

packages/core/tests/cases/cross-entries/default-export-with-default-direct-reexport.ts

@@ -0,0 +1,2 @@
+export { DefaultImport } from '@test-cases/default-export/with-default-direct-reexport';
+export { DefaultImportDupe } from '@test-cases/default-export/with-default-direct-reexport';

packages/core/tests/cases/cross-entries/default-export-with-default-import-reexport.ts

@@ -0,0 +1,2 @@
+export { DefaultImport } from '@test-cases/default-export/with-default-import-reexport';
+export { DefaultImportDupe } from '@test-cases/default-export/with-default-import-reexport';

packages/core/tests/cases/cross-entries/default-export-with-destructured-default-import.ts

@@ -0,0 +1,2 @@
+export { DefaultImport } from '@test-cases/default-export/with-destructured-default-import';
+export { DefaultImportDupe } from '@test-cases/default-export/with-destructured-default-import';

packages/core/tests/cases/cross-entries/index.test.ts

@@ -0,0 +1,3 @@
+import { testCrossEntriesImportsExports } from './setup';
+
+testCrossEntriesImportsExports();

packages/core/tests/cases/cross-entries/mixed-imports.ts

@@ -0,0 +1,2 @@
+export { MixedDefault, MixedImportNamed } from '@test-cases/mixed-imports/mixed';
+export default "Some default export";

packages/core/tests/cases/cross-entries/named-export-direct-reexport-multiple.ts

@@ -0,0 +1,2 @@
+export { NamedExportOne, NamedExportTwo  } from '@test-cases/named-export-direct-reexport/multiple';
+export { NamedExportOneDupe, NamedExportTwoDupe } from '@test-cases/named-export-direct-reexport/multiple';

packages/core/tests/cases/cross-entries/named-export-direct-reexport-single.ts

@@ -0,0 +1,2 @@
+export { NamedExportOne } from '@test-cases/named-export-direct-reexport/single';
+export { NamedExportOneDupe } from '@test-cases/named-export-direct-reexport/single';

packages/core/tests/cases/cross-entries/named-export-import-reexport-alias-via-export-multiple.ts

@@ -0,0 +1,2 @@
+export { NamedExportOne, AliasedNamedExportTwo } from '@test-cases/named-export-import-reexport-alias-via-export/multiple';
+export { NamedExportOneDupe } from '@test-cases/named-export-import-reexport-alias-via-export/multiple';

packages/core/tests/cases/cross-entries/named-export-import-reexport-alias-via-export-single.ts

@@ -0,0 +1,2 @@
+export { AliasedNamedExportOne } from '@test-cases/named-export-import-reexport-alias-via-export/single';
+export { NamedExportOneDupe } from '@test-cases/named-export-import-reexport-alias-via-export/single';

packages/core/tests/cases/cross-entries/named-export-import-reexport-alias-via-import-multiple.ts

@@ -0,0 +1,2 @@
+export { AliasedNamedExportOne, AliasedNamedExportTwo } from '@test-cases/named-export-import-reexport-alias-via-import/multiple';
+export { NamedExportOneDupe } from '@test-cases/named-export-import-reexport-alias-via-import/multiple';

packages/core/tests/cases/cross-entries/named-export-import-reexport-alias-via-import-single.ts

@@ -0,0 +1,2 @@
+export { AliasedNamedExportOne } from '@test-cases/named-export-import-reexport-alias-via-import/single';
+export { NamedExportOneDupe } from '@test-cases/named-export-import-reexport-alias-via-import/single';

packages/core/tests/cases/cross-entries/named-export-import-reexport-multiple.ts

@@ -0,0 +1,2 @@
+export { NamedExportOne, NamedExportTwo  } from '@test-cases/named-export-import-reexport/multiple';
+export { NamedExportOneDupe, NamedExportTwoDupe } from '@test-cases/named-export-import-reexport/multiple';

packages/core/tests/cases/cross-entries/named-export-import-reexport-single.ts

@@ -0,0 +1,2 @@
+export { NamedExportOne } from '@test-cases/named-export-import-reexport/single';
+export { NamedExportOneDupe } from '@test-cases/named-export-import-reexport/single';

packages/core/tests/cases/cross-entries/setup.ts

@@ -0,0 +1,86 @@
+import { describe } from 'vitest';
+import { createCaseTarget } from '../../utils';
+
+import {
+  testNamedExportDirectReexportSingle,
+  testNamedExportDirectReexportMultiple,
+} from '../named-export-direct-reexport/setup';
+
+import {
+  testNamedExportImportReexportSingle,
+  testNamedExportImportReexportMultiple,
+} from '../named-export-import-reexport/setup';
+
+import {
+  testNamedExportImportReexportAliasViaExportSingle,
+  testNamedExportImportReexportAliasViaExportMultiple,
+} from '../named-export-import-reexport-alias-via-export/setup';
+
+import {
+  testNamedExportImportReexportAliasViaImportSingle,
+  testNamedExportImportReexportAliasViaImportMultiple,
+} from '../named-export-import-reexport-alias-via-import/setup';
+
+import {
+  testMixedImportsInTarget,
+  testMixedImportsOfTarget
+} from '../mixed-imports/setup';
+
+import {
+  testHasDefaultExport,
+  testWithDefaultDirectReexport,
+  testWithDefaultImportReexport,
+  testWithDestructuredDefaultImport,
+} from '../default-export/setup'
+
+const casePath = '@test-cases/cross-entries';
+
+/**
+ * The following tests suppose some file imports data from a `second` target which
+ * exposes some code re-exported from a `first` target. When testing cross-entries
+ * imports/exports, we also want to make sure all supported syntaxes work properly.
+ * There are a lot of possible cases and so as to o reduce code duplication, let's
+ * use other syntax-specific cases as a `first` target.
+ */
+export function testCrossEntriesImportsExports() {
+  describe('Cross-entries imports/exports', () => {
+    describe('direct re-export', async () => {
+      const baseCasePath = `${casePath}/named-export-direct-reexport`;
+      testNamedExportDirectReexportSingle(await createCaseTarget(`${baseCasePath}-single`));
+      testNamedExportDirectReexportMultiple(await createCaseTarget(`${baseCasePath}-multiple`));
+    });
+
+    describe('import then re-export', async () => {
+      const baseCasePath = `${casePath}/named-export-import-reexport`;
+      testNamedExportImportReexportSingle(await createCaseTarget(`${baseCasePath}-single`));
+      testNamedExportImportReexportMultiple(await createCaseTarget(`${baseCasePath}-multiple`));
+    });
+
+    describe('import then re-export an alias set via export', async () => {
+      const baseCasePath = `${casePath}/named-export-import-reexport-alias-via-export`;
+      testNamedExportImportReexportAliasViaExportSingle(await createCaseTarget(`${baseCasePath}-single`));
+      testNamedExportImportReexportAliasViaExportMultiple(await createCaseTarget(`${baseCasePath}-multiple`));
+    });
+
+    describe('import then re-export an alias set via import', async () => {
+      const baseCasePath = `${casePath}/named-export-import-reexport-alias-via-import`;
+      testNamedExportImportReexportAliasViaImportSingle(await createCaseTarget(`${baseCasePath}-single`));
+      testNamedExportImportReexportAliasViaImportMultiple(await createCaseTarget(`${baseCasePath}-multiple`));
+    });
+
+    describe('mixed imports', async () => {
+      const baseCasePath = `${casePath}/mixed-imports`;
+      testMixedImportsInTarget(await createCaseTarget(`${baseCasePath}`));
+      testMixedImportsOfTarget(await createCaseTarget(`${baseCasePath}`));
+    });
+
+    describe('default export', async () => {
+      const baseCasePath = `${casePath}/default-export`;
+      testHasDefaultExport(await createCaseTarget(`${baseCasePath}-has-default-export`))
+      testWithDefaultDirectReexport(await createCaseTarget(`${baseCasePath}-with-default-direct-reexport`))
+      testWithDefaultImportReexport(await createCaseTarget(`${baseCasePath}-with-default-import-reexport`))
+      testWithDestructuredDefaultImport(await createCaseTarget(`${baseCasePath}-with-destructured-default-import`))
+    })
+  });
+}
+

packages/core/tests/cases/mixed-imports/relative.ts → packages/core/tests/cases/default-export/has-default-export.ts

@@ -1,9 +1,7 @@
-import MixedDefault, { MixedImportNamed } from '../../__mocks__/modules/mixed-import';
-export { MixedDefault, MixedImportNamed };
+export default "Default export from target";
 
 /** Below content should not be removed from the transformed target. */
 import { ConsumedExport } from '@test-modules/consumed-export';
 export const ExportDefinedFromTarget = 'ExportDefinedFromTarget';
 const CodeDefinedFromTarget = `CodeDefinedFromTarget: ${ConsumedExport}`;
 console.info('This is being printed from target, which means target was requested', CodeDefinedFromTarget);
-export default "Default export from target";

packages/core/tests/cases/default-export/index.test.ts

@@ -1,74 +1,3 @@
-import { describe, it } from 'vitest';
-import { resolvePath, resolveModule, testCase, getPathTypeDescribeLabel } from '../../utils';
+import { testDefaultExport } from './setup';
 
-const casePath = '@test-cases/default-export';
-
-describe('Default imports/exports', () => {
-  describe('re-exporting default imports from target', async () => {
-    const testTarget = async (targetName: string) => {
-      const describeLabel = getPathTypeDescribeLabel(targetName);
-
-      describe(describeLabel, () => {
-        it(`should work when target re-exports a simple default import`, async () => {
-          const resolved = await resolveModule('default-export');
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import { DefaultImport } from '${target}';\n`;
-          const output = `import { default as DefaultImport } from '${resolved}';\n`;
-          await testCase(target, input, output, 3);
-        });
-
-        it('should work when target re-exports several aliases of a default import', async () => {
-          const resolved = await resolveModule('default-export');
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import { DefaultImport, DefaultImportDupe } from '${target}';\n`;
-          const output = `import { default as DefaultImport, default as DefaultImportDupe } from '${resolved}';\n`;
-          await testCase(target, input, output, 3);
-        });
-
-        it('should work when target re-exports an aliased default import', async () => {
-          // e.g. `import { default as Alias } from './some-module'`
-          const resolved = await resolveModule('default-export');
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import { YetAnotherDefaultImport } from '${target}';\n`;
-          const output = `import { default as YetAnotherDefaultImport } from '${resolved}';\n`;
-          await testCase(target, input, output, 3);
-        });
-      });
-    };
-
-    await testTarget('relative');
-    await testTarget('alias');
-  });
-
-  describe('re-exporting default export of target', async () => {
-    const testTarget = async (targetName: string) => {
-      const describeLabel = getPathTypeDescribeLabel(targetName);
-
-      describe(describeLabel, () => {
-        it(`should work when simply importing target's default export`, async () => {
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import DefaultImport from '${target}';\n`;
-          const output = `import { default as DefaultImport } from '${target}';\n`;
-          await testCase(target, input, output, 3);
-        });
-
-        it(`should work when importing target's default export with explicit default keyword`, async () => {
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import { default as Something } from '${target}';\n`;
-          const output = `import { default as Something } from '${target}';\n`;
-          await testCase(target, input, output, 3);
-        });
-
-        it(`should work when importing target's default export multiple times`, async () => {
-          const target = await resolvePath(`${casePath}/${targetName}`);
-          const input = `import { default as Something, default as SomethingElse } from '${target}';\n`;
-          const output = `import { default as Something, default as SomethingElse } from '${target}';\n`;
-          await testCase(target, input, output, 3);
-        });
-      });
-    };
-
-    await testTarget('relative');
-    await testTarget('alias');
-  });
-});
+testDefaultExport()