@esmx/core 3.0.0-rc.69 → 3.0.0-rc.71

package/src/utils/import-map.ts

@@ -22,7 +22,7 @@ export interface GetImportMapOptions {
     getFile: (name: string, file: string) => string;
 }
 
-export function buildImportsMap(
+export function createImportsMap(
     manifests: readonly ImportMapManifest[],
     getFile: (name: string, file: string) => string
 ): SpecifierMap {
@@ -40,7 +40,7 @@ export function buildImportsMap(
     return imports;
 }
 
-export function buildScopesMap(
+export function createScopesMap(
     imports: SpecifierMap,
     manifests: readonly ImportMapManifest[],
     getScope: (name: string, scope: string) => string
@@ -73,18 +73,19 @@ export function buildScopesMap(
     return scopes;
 }
 /**
- * Fixes Chrome's nested scope resolution bug in import maps.
+ * Fixes the nested scope resolution issue in import maps across all browsers.
  *
- * Chrome has a bug where nested scopes in import maps are not resolved correctly.
+ * Import Maps have a cross-browser issue where nested scopes are not resolved correctly.
  * For example, when you have both "/shared-modules/" and "/shared-modules/vue2/" scopes,
- * Chrome fails to properly apply the more specific nested scope.
+ * browsers fail to properly apply the more specific nested scope.
  *
- * This function works around the bug by:
+ * This function works around the issue by:
  * 1. Sorting scopes by path depth (shallow paths first, deeper paths last)
  * 2. Manually applying scopes to matching imports in the correct order
+ * 3. Converting pattern-based scopes to concrete path scopes
  *
  * @example
- * Problematic import map that fails in Chrome:
+ * Problematic import map that fails in browsers:
  * ```json
  * {
  *   "scopes": {
@@ -101,7 +102,7 @@ export function buildScopesMap(
  * @see https://github.com/guybedford/es-module-shims/issues/529
  * @see https://issues.chromium.org/issues/453147451
  */
-export function fixNestedScopesResolution(
+export function fixImportMapNestedScopes(
     importMap: Required<ImportMap>
 ): Required<ImportMap> {
     Object.entries(importMap.scopes)
@@ -125,16 +126,77 @@ export function fixNestedScopesResolution(
     return importMap;
 }
 
-export function getImportMap({
+export function compressImportMap(importMap: Required<ImportMap>): ImportMap {
+    const compressed: Required<ImportMap> = {
+        imports: { ...importMap.imports },
+        scopes: {}
+    };
+
+    const counts: Record<string, Record<string, number>> = {};
+    Object.values(importMap.scopes).forEach((scopeMappings) => {
+        Object.entries(scopeMappings).forEach(([specifier, target]) => {
+            if (Object.hasOwn(importMap.imports, specifier)) return;
+            counts[specifier] ??= {};
+            counts[specifier][target] = (counts[specifier][target] ?? 0) + 1;
+        });
+    });
+
+    Object.entries(counts).forEach(([specifier, targetCounts]) => {
+        const entries = Object.entries(targetCounts);
+
+        let best: [string, number] | null = null;
+        let secondBestCount = 0;
+        for (const [t, c] of entries) {
+            if (!best || c > best[1]) {
+                secondBestCount = best
+                    ? Math.max(secondBestCount, best[1])
+                    : secondBestCount;
+                best = [t, c];
+            } else {
+                secondBestCount = Math.max(secondBestCount, c);
+            }
+        }
+        if (best && best[1] > secondBestCount) {
+            compressed.imports[specifier] = best[0];
+        }
+    });
+
+    Object.entries(importMap.scopes).forEach(([scopePath, scopeMappings]) => {
+        const filtered: SpecifierMap = {};
+
+        Object.entries(scopeMappings).forEach(([specifier, target]) => {
+            const globalTarget = compressed.imports[specifier];
+            if (globalTarget === target) {
+                return;
+            }
+            filtered[specifier] = target;
+        });
+
+        if (Object.keys(filtered).length > 0) {
+            compressed.scopes[scopePath] = filtered;
+        }
+    });
+
+    const hasScopes = Object.keys(compressed.scopes).length > 0;
+    return hasScopes ? compressed : { imports: compressed.imports };
+}
+
+export function createImportMap({
     manifests,
     getFile,
     getScope
 }: GetImportMapOptions): Required<ImportMap> {
-    const imports = buildImportsMap(manifests, getFile);
+    const imports = createImportsMap(manifests, getFile);
 
-    const scopes = buildScopesMap(imports, manifests, getScope);
+    const scopes = createScopesMap(imports, manifests, getScope);
     return {
         imports,
         scopes
     };
 }
+
+export function createClientImportMap(options: GetImportMapOptions): ImportMap {
+    const base = createImportMap(options);
+    const fixed = fixImportMapNestedScopes(base);
+    return compressImportMap(fixed);
+}