@esmx/core 3.0.0-rc.59 → 3.0.0-rc.60

package/src/utils/import-map.test.ts

@@ -1,145 +1,1242 @@
-import { assert, expect, test } from 'vitest';
-import { getImportMap } from './import-map';
+import { assert, describe, test } from 'vitest';
+import { buildImportsMap, buildScopesMap, getImportMap } from './import-map';
+import type { GetImportMapOptions, ImportMapManifest } from './import-map';
 
-test('should return empty import map when no manifests provided', async () => {
-    assert.deepEqual(
-        getImportMap({
-            manifests: [],
-            getScope(name) {
-                return `/${name}/`;
-            },
-            getFile(name, file) {
-                return `${name}/${file}`;
-            }
-        }),
-        {
-            imports: {},
-            scopes: {}
-        }
-    );
-});
+describe('buildImportsMap', () => {
+    test('should return empty object for empty manifests', () => {
+        const result = buildImportsMap([], (name, file) => `${name}/${file}`);
+        assert.deepEqual(result, {});
+    });
 
-test('should generate import map with remote exports and module scopes', async () => {
-    const result = getImportMap({
-        manifests: [
+    test('should process all exports including package exports', () => {
+        const manifests: ImportMapManifest[] = [
             {
-                name: 'ssr-vue2-remote',
+                name: 'test-module',
                 imports: {},
                 exports: {
-                    'src/entry.server': {
-                        name: 'src/entry.server',
-                        rewrite: true,
-                        file: 'src/entry.server.mjs',
-                        identifier: 'ssr-vue2-remote/src/entry.server'
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
                     },
                     vue: {
                         name: 'vue',
-                        rewrite: false,
-                        file: 'vue.mjs',
-                        identifier: 'ssr-vue2-remote/vue'
+                        pkg: true,
+                        file: 'vue.js',
+                        identifier: 'test-module/vue'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/component': 'test-module/component.js',
+            'test-module/vue': 'test-module/vue.js'
+        });
+    });
+
+    test('should handle user imports with existing identifiers', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    'custom-name': 'test-module/component'
+                },
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/component': 'test-module/component.js',
+            'test-module/custom-name': 'test-module/component.js'
+        });
+    });
+
+    test('should handle user imports with non existing identifiers', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    external: 'https://cdn.com/lib.js'
+                },
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/component': 'test-module/component.js',
+            'test-module/external': 'https://cdn.com/lib.js'
+        });
+    });
+
+    test('should create aliases for index suffixes', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    'src/index': {
+                        name: 'src/index',
+                        pkg: false,
+                        file: 'src/index.js',
+                        identifier: 'test-module/src/index'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/src/index': 'test-module/src/index.js',
+            'test-module/src': 'test-module/src/index.js'
+        });
+    });
+
+    test('should handle multiple manifests', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'module-a',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'module-a/utils'
+                    }
+                },
+                scopes: {}
+            },
+            {
+                name: 'module-b',
+                imports: {
+                    shared: 'module-a/utils'
+                },
+                exports: {},
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'module-a/utils': 'module-a/utils.js',
+            'module-b/shared': 'module-a/utils.js'
+        });
+    });
+
+    test('should prioritize user imports', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    react: 'preact',
+                    vue: './custom/vue.js'
+                },
+                exports: {
+                    react: {
+                        name: 'react',
+                        pkg: false,
+                        file: 'react.js',
+                        identifier: 'test-module/react'
                     },
+                    vue: {
+                        name: 'vue',
+                        pkg: false,
+                        file: 'vue.js',
+                        identifier: 'test-module/vue'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/react': 'preact',
+            'test-module/vue': './custom/vue.js'
+        });
+    });
+
+    test('should handle mixed user import types', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    'url-import': 'https://example.com/lib.js',
+                    'relative-import': './local/file.js',
+                    'identifier-import': 'test-module/component'
+                },
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/component': 'test-module/component.js',
+            'test-module/url-import': 'https://example.com/lib.js',
+            'test-module/relative-import': './local/file.js',
+            'test-module/identifier-import': 'test-module/component.js'
+        });
+    });
+
+    test('should handle empty exports', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    external: 'https://cdn.com/lib.js'
+                },
+                exports: {},
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/external': 'https://cdn.com/lib.js'
+        });
+    });
+
+    test('should handle empty imports', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/component': 'test-module/component.js'
+        });
+    });
+
+    test('should handle duplicate alias creation', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
                     'src/components/index': {
                         name: 'src/components/index',
-                        rewrite: true,
-                        file: 'src/components/index.mjs',
-                        identifier: 'ssr-vue2-remote/src/components/index'
+                        pkg: false,
+                        file: 'src/components/index.js',
+                        identifier: 'test-module/src/components/index'
                     }
-                }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/src/components/index':
+                'test-module/src/components/index.js',
+            'test-module/src/components': 'test-module/src/components/index.js'
+        });
+    });
+
+    test('should handle cross-module references', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'module-a',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'module-a/utils'
+                    }
+                },
+                scopes: {}
             },
             {
-                name: 'ssr-vue2-host',
+                name: 'module-b',
                 imports: {
-                    vue: 'ssr-vue2-remote/vue'
-                },
-                exports: {}
-            }
-        ],
-        getScope(name) {
-            return `/${name}/`;
-        },
-        getFile(name, file) {
-            return `${name}/${file}`;
-        }
-    });
-    assert.deepEqual(result, {
-        imports: {
-            'ssr-vue2-remote/src/entry.server':
-                'ssr-vue2-remote/src/entry.server.mjs',
-            'ssr-vue2-remote/vue': 'ssr-vue2-remote/vue.mjs',
-            'ssr-vue2-remote/src/components/index':
-                'ssr-vue2-remote/src/components/index.mjs',
-            'ssr-vue2-remote/src/components':
-                'ssr-vue2-remote/src/components/index.mjs'
-        },
-        scopes: {
-            '/ssr-vue2-host/': {
-                vue: 'ssr-vue2-remote/vue.mjs'
+                    shared: 'module-a/utils'
+                },
+                exports: {},
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'module-a/utils': 'module-a/utils.js',
+            'module-b/shared': 'module-a/utils.js'
+        });
+    });
+
+    test('should handle cross-module non-existent references', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'module-a',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'module-a/utils'
+                    }
+                },
+                scopes: {}
             },
-            '/ssr-vue2-remote/': { vue: 'ssr-vue2-remote/vue.mjs' }
-        }
+            {
+                name: 'module-b',
+                imports: {
+                    external: 'module-a/non-existent'
+                },
+                exports: {},
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'module-a/utils': 'module-a/utils.js',
+            'module-b/external': 'module-a/non-existent'
+        });
+    });
+
+    test('should handle identifier conflicts across modules', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'module-a',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils-a.js',
+                        identifier: 'module-a/utils'
+                    }
+                },
+                scopes: {}
+            },
+            {
+                name: 'module-b',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils-b.js',
+                        identifier: 'module-b/utils'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'module-a/utils': 'module-a/utils-a.js',
+            'module-b/utils': 'module-b/utils-b.js'
+        });
+    });
+
+    test('should handle user imports referencing aliased identifiers', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {
+                    'alias-test': 'test-module/src/index'
+                },
+                exports: {
+                    'src/index': {
+                        name: 'src/index',
+                        pkg: false,
+                        file: 'src/index.js',
+                        identifier: 'test-module/src/index'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/src/index': 'test-module/src/index.js',
+            'test-module/src': 'test-module/src/index.js',
+            'test-module/alias-test': 'test-module/src/index.js'
+        });
+    });
+
+    test('should handle nested index aliases', () => {
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    'src/components/utils/index': {
+                        name: 'src/components/utils/index',
+                        pkg: false,
+                        file: 'src/components/utils/index.js',
+                        identifier: 'test-module/src/components/utils/index'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+
+        const result = buildImportsMap(
+            manifests,
+            (name, file) => `${name}/${file}`
+        );
+
+        assert.deepEqual(result, {
+            'test-module/src/components/utils/index':
+                'test-module/src/components/utils/index.js',
+            'test-module/src/components/utils':
+                'test-module/src/components/utils/index.js'
+        });
     });
 });
-test('should generate import map with remote exports and module scopes', async () => {
-    const result = getImportMap({
-        manifests: [
+
+describe('buildScopesMap', () => {
+    test('should return empty object for empty manifests', () => {
+        const imports = {};
+        const manifests: ImportMapManifest[] = [];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {});
+    });
+
+    test('should return empty object when manifests have no scopes', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
             {
-                name: 'ssr-vue2-remote',
+                name: 'test-module',
                 imports: {},
                 exports: {
-                    vue: {
-                        name: 'vue',
-                        rewrite: false,
-                        file: 'vue.mjs',
-                        identifier: 'ssr-vue2-remote/vue'
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {}
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {});
+    });
+
+    test('should build scopes map with basic scope configuration', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js',
+            'test-module/utils': 'test-module/utils.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    },
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'test-module/utils'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'test-module/component',
+                        lodash: 'test-module/utils'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//node_modules': {
+                react: 'test-module/component.js',
+                lodash: 'test-module/utils.js'
+            }
+        });
+    });
+
+    test('should handle scope with non-existent identifiers', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'test-module/component',
+                        'non-existent': 'test-module/non-existent'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//node_modules': {
+                react: 'test-module/component.js',
+                'non-existent': 'test-module/non-existent'
+            }
+        });
+    });
+
+    test('should handle scope with external URLs', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'https://cdn.com/react.js',
+                        'local-component': 'test-module/component'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//node_modules': {
+                react: 'https://cdn.com/react.js',
+                'local-component': 'test-module/component.js'
+            }
+        });
+    });
+
+    test('should use scope path from imports when available', () => {
+        const imports = {
+            'test-module/node_modules': 'test-module/node_modules/index.js',
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    node_modules: {
+                        name: 'node_modules',
+                        pkg: false,
+                        file: 'node_modules/index.js',
+                        identifier: 'test-module/node_modules'
+                    },
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'test-module/component'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module/test-module/node_modules/index.js': {
+                react: 'test-module/component.js'
+            }
+        });
+    });
+
+    test('should fall back to scope path when not found in imports', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'test-module/component'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//node_modules': {
+                react: 'test-module/component.js'
+            }
+        });
+    });
+
+    test('should handle multiple scopes in single manifest', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js',
+            'test-module/utils': 'test-module/utils.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    },
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'test-module/utils'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'test-module/component'
+                    },
+                    vendor: {
+                        lodash: 'test-module/utils'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//node_modules': {
+                react: 'test-module/component.js'
+            },
+            'test-module//vendor': {
+                lodash: 'test-module/utils.js'
+            }
+        });
+    });
+
+    test('should handle multiple manifests with scopes', () => {
+        const imports = {
+            'module-a/component': 'module-a/component.js',
+            'module-b/utils': 'module-b/utils.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'module-a',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'module-a/component'
+                    }
+                },
+                scopes: {
+                    node_modules: {
+                        react: 'module-a/component'
                     }
                 }
             },
             {
-                name: 'ssr-vue2-host',
-                imports: {
-                    vue: 'ssr-vue2-remote/vue3'
+                name: 'module-b',
+                imports: {},
+                exports: {
+                    utils: {
+                        name: 'utils',
+                        pkg: false,
+                        file: 'utils.js',
+                        identifier: 'module-b/utils'
+                    }
                 },
-                exports: {}
+                scopes: {
+                    vendor: {
+                        lodash: 'module-b/utils'
+                    }
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'module-a//node_modules': {
+                react: 'module-a/component.js'
+            },
+            'module-b//vendor': {
+                lodash: 'module-b/utils.js'
             }
-        ],
-        getScope(name) {
-            return `/${name}/`;
-        },
-        getFile(name, file) {
-            return `${name}/${file}`;
-        }
+        });
     });
-    assert.deepEqual(result, {
-        imports: { 'ssr-vue2-remote/vue': 'ssr-vue2-remote/vue.mjs' },
-        scopes: {
-            '/ssr-vue2-remote/': { vue: 'ssr-vue2-remote/vue.mjs' },
-            '/ssr-vue2-host/': { vue: 'ssr-vue2-remote/vue3' }
-        }
+
+    test('should handle empty scope specifier map', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: {
+                    './node_modules': {}
+                }
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {
+            'test-module//./node_modules': {}
+        });
+    });
+
+    test('should handle undefined scopes property', () => {
+        const imports = {
+            'test-module/component': 'test-module/component.js'
+        };
+        const manifests: ImportMapManifest[] = [
+            {
+                name: 'test-module',
+                imports: {},
+                exports: {
+                    component: {
+                        name: 'component',
+                        pkg: false,
+                        file: 'component.js',
+                        identifier: 'test-module/component'
+                    }
+                },
+                scopes: undefined as any
+            }
+        ];
+        const result = buildScopesMap(
+            imports,
+            manifests,
+            (name, scope) => `${name}/${scope}`
+        );
+        assert.deepEqual(result, {});
     });
 });
 
-test('should throw error when encountering legacy format manifests', async () => {
-    // 模拟旧版本的清单格式，其中 exports 的值是字符串而不是对象
-    const legacyManifest = {
-        name: 'legacy-module',
-        imports: {},
-        exports: {
-            'legacy-export': 'legacy-module/legacy-file.js'
-        } as any
-    };
-
-    const expectedErrorMessage =
-        'Detected incompatible legacy manifest format in legacy-module. Please upgrade your ESMX dependencies first, then rebuild and redeploy your service.';
-
-    expect(() => {
-        getImportMap({
-            manifests: [legacyManifest],
-            getScope(name) {
-                return `/${name}/`;
+describe('getImportMap', () => {
+    test('should return empty import map for empty manifests', () => {
+        const options: GetImportMapOptions = {
+            manifests: [],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {},
+            scopes: {}
+        });
+    });
+
+    test('should build complete import map with imports and scopes', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {
+                        'custom-react': 'test-module/component'
+                    },
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'test-module/component'
+                        },
+                        utils: {
+                            name: 'utils',
+                            pkg: false,
+                            file: 'utils.js',
+                            identifier: 'test-module/utils'
+                        }
+                    },
+                    scopes: {
+                        node_modules: {
+                            react: 'test-module/component',
+                            lodash: 'test-module/utils'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/component': 'test-module/component.js',
+                'test-module/utils': 'test-module/utils.js',
+                'test-module/custom-react': 'test-module/component.js'
+            },
+            scopes: {
+                'test-module//node_modules': {
+                    react: 'test-module/component.js',
+                    lodash: 'test-module/utils.js'
+                }
+            }
+        });
+    });
+
+    test('should handle complex multi-module scenario', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'module-a',
+                    imports: {},
+                    exports: {
+                        utils: {
+                            name: 'utils',
+                            pkg: false,
+                            file: 'utils.js',
+                            identifier: 'module-a/utils'
+                        }
+                    },
+                    scopes: {
+                        node_modules: {
+                            react: 'module-a/utils'
+                        }
+                    }
+                },
+                {
+                    name: 'module-b',
+                    imports: {
+                        shared: 'module-a/utils'
+                    },
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'module-b/component'
+                        }
+                    },
+                    scopes: {
+                        vendor: {
+                            lodash: 'module-a/utils'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'module-a/utils': 'module-a/utils.js',
+                'module-b/component': 'module-b/component.js',
+                'module-b/shared': 'module-a/utils.js'
+            },
+            scopes: {
+                'module-a//node_modules': {
+                    react: 'module-a/utils.js'
+                },
+                'module-b//vendor': {
+                    lodash: 'module-a/utils.js'
+                }
+            }
+        });
+    });
+
+    test('should handle manifests with only exports', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {},
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'test-module/component'
+                        }
+                    },
+                    scopes: {}
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/component': 'test-module/component.js'
+            },
+            scopes: {}
+        });
+    });
+
+    test('should handle manifests with only imports', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {
+                        external: 'https://cdn.com/lib.js'
+                    },
+                    exports: {},
+                    scopes: {}
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/external': 'https://cdn.com/lib.js'
+            },
+            scopes: {}
+        });
+    });
+
+    test('should handle manifests with only scopes', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {},
+                    exports: {},
+                    scopes: {
+                        node_modules: {
+                            react: 'https://cdn.com/react.js'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {},
+            scopes: {
+                'test-module//node_modules': {
+                    react: 'https://cdn.com/react.js'
+                }
+            }
+        });
+    });
+
+    test('should handle custom getFile and getScope functions', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {},
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'test-module/component'
+                        }
+                    },
+                    scopes: {
+                        node_modules: {
+                            react: 'test-module/component'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `/custom/path/${name}/${file}`,
+            getScope: (name, scope) => `custom-scope-${name}-${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/component': '/custom/path/test-module/component.js'
+            },
+            scopes: {
+                'custom-scope-test-module-/node_modules': {
+                    react: '/custom/path/test-module/component.js'
+                }
+            }
+        });
+    });
+
+    test('should handle edge case with undefined scopes in manifests', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {},
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'test-module/component'
+                        }
+                    },
+                    scopes: undefined as any
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/component': 'test-module/component.js'
+            },
+            scopes: {}
+        });
+    });
+
+    test('should handle mixed scenarios with external URLs and local modules', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {
+                        'external-react': 'https://cdn.com/react.js',
+                        'local-alias': 'test-module/component'
+                    },
+                    exports: {
+                        component: {
+                            name: 'component',
+                            pkg: false,
+                            file: 'component.js',
+                            identifier: 'test-module/component'
+                        }
+                    },
+                    scopes: {
+                        node_modules: {
+                            'external-lib': 'https://cdn.com/lodash.js',
+                            'local-lib': 'test-module/component'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/component': 'test-module/component.js',
+                'test-module/external-react': 'https://cdn.com/react.js',
+                'test-module/local-alias': 'test-module/component.js'
+            },
+            scopes: {
+                'test-module//node_modules': {
+                    'external-lib': 'https://cdn.com/lodash.js',
+                    'local-lib': 'test-module/component.js'
+                }
+            }
+        });
+    });
+
+    test('should handle index path aliases in complete import map', () => {
+        const options: GetImportMapOptions = {
+            manifests: [
+                {
+                    name: 'test-module',
+                    imports: {},
+                    exports: {
+                        'src/index': {
+                            name: 'src/index',
+                            pkg: false,
+                            file: 'src/index.js',
+                            identifier: 'test-module/src/index'
+                        }
+                    },
+                    scopes: {
+                        src: {
+                            main: 'test-module/src/index'
+                        }
+                    }
+                }
+            ],
+            getFile: (name, file) => `${name}/${file}`,
+            getScope: (name, scope) => `${name}/${scope}`
+        };
+        const result = getImportMap(options);
+        assert.deepEqual(result, {
+            imports: {
+                'test-module/src/index': 'test-module/src/index.js',
+                'test-module/src': 'test-module/src/index.js'
             },
-            getFile(name, file) {
-                return `${name}/${file}`;
+            scopes: {
+                'test-module/test-module/src/index.js': {
+                    main: 'test-module/src/index.js'
+                }
             }
         });
-    }).toThrowError(expectedErrorMessage);
+    });
 });