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

package/dist/utils/import-map.test.mjs

@@ -1,135 +1,1171 @@
-import { assert, expect, test } from "vitest";
-import { getImportMap } from "./import-map.mjs";
-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: {}
-    }
-  );
-});
-test("should generate import map with remote exports and module scopes", async () => {
-  const result = getImportMap({
-    manifests: [
+import { assert, describe, test } from "vitest";
+import { buildImportsMap, buildScopesMap, getImportMap } from "./import-map.mjs";
+describe("buildImportsMap", () => {
+  test("should return empty object for empty manifests", () => {
+    const result = buildImportsMap([], (name, file) => `${name}/${file}`);
+    assert.deepEqual(result, {});
+  });
+  test("should process all exports including package exports", () => {
+    const manifests = [
       {
-        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [];
+    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 = [
       {
-        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
+      {
+        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 = [
       {
-        name: "ssr-vue2-host",
-        imports: {
-          vue: "ssr-vue2-remote/vue3"
+        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: "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 = [
+      {
+        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 = [
+      {
+        name: "test-module",
+        imports: {},
+        exports: {
+          component: {
+            name: "component",
+            pkg: false,
+            file: "component.js",
+            identifier: "test-module/component"
+          }
+        },
+        scopes: void 0
+      }
+    ];
+    const result = buildScopesMap(
+      imports,
+      manifests,
+      (name, scope) => `${name}/${scope}`
+    );
+    assert.deepEqual(result, {});
   });
 });
-test("should throw error when encountering legacy format manifests", async () => {
-  const legacyManifest = {
-    name: "legacy-module",
-    imports: {},
-    exports: {
-      "legacy-export": "legacy-module/legacy-file.js"
-    }
-  };
-  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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      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 = {
+      manifests: [
+        {
+          name: "test-module",
+          imports: {},
+          exports: {
+            component: {
+              name: "component",
+              pkg: false,
+              file: "component.js",
+              identifier: "test-module/component"
+            }
+          },
+          scopes: void 0
+        }
+      ],
+      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 = {
+      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"
       },
-      getFile(name, file) {
-        return `${name}/${file}`;
+      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 = {
+      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"
+      },
+      scopes: {
+        "test-module/test-module/src/index.js": {
+          main: "test-module/src/index.js"
+        }
       }
     });
-  }).toThrowError(expectedErrorMessage);
+  });
 });