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

package/src/utils/import-map.ts

@@ -11,50 +11,84 @@ export interface ImportMapManifest {
             name: string;
             file: string;
             identifier: string;
-            rewrite: boolean;
+            pkg: boolean;
         }
     >;
+    scopes: Record<string, Record<string, string>>;
 }
 
-export function getImportMap({
-    manifests,
-    getFile,
-    getScope
-}: {
+export interface GetImportMapOptions {
     manifests: readonly ImportMapManifest[];
-    getScope: (name: string) => string;
+    getScope: (name: string, scope: string) => string;
     getFile: (name: string, file: string) => string;
-}): ImportMap {
-    const imports: SpecifierMap = {};
-    const scopes: ScopesMap = {};
-    Object.values(manifests).forEach((manifest) => {
-        const scopeImports: SpecifierMap = {};
+}
 
-        Object.entries(manifest.exports).forEach(([key, exportItem]) => {
-            // Handle the case where exportItem is a string in legacy builds
-            if (typeof exportItem === 'string') {
-                throw new Error(
-                    `Detected incompatible legacy manifest format in ${manifest.name}. Please upgrade your ESMX dependencies first, then rebuild and redeploy your service.`
-                );
-            }
+export function buildImportsMap(
+    manifests: readonly ImportMapManifest[],
+    getFile: (name: string, file: string) => string
+): SpecifierMap {
+    const imports: SpecifierMap = {};
 
+    manifests.forEach((manifest) => {
+        Object.entries(manifest.exports).forEach(([, exportItem]) => {
             const file = getFile(manifest.name, exportItem.file);
             imports[exportItem.identifier] = file;
-            if (!exportItem.rewrite) {
-                scopeImports[exportItem.name] = file;
-            }
         });
-        if (Object.keys(scopeImports).length || Object.keys(imports).length) {
-            scopes[getScope(manifest.name)] = scopeImports;
-        }
     });
-    pathWithoutIndex(imports);
-    Object.values(manifests).forEach((manifest) => {
+
+    manifests.forEach((manifest) => {
         Object.entries(manifest.imports).forEach(([name, identifier]) => {
-            scopes[getScope(manifest.name)][name] =
-                imports[identifier] ?? identifier;
+            const fullName = `${manifest.name}/${name}`;
+            imports[fullName] = imports[identifier] ?? identifier;
         });
     });
+
+    pathWithoutIndex(imports);
+
+    return imports;
+}
+
+export function buildScopesMap(
+    imports: SpecifierMap,
+    manifests: readonly ImportMapManifest[],
+    getScope: (name: string, scope: string) => string
+): ScopesMap {
+    const scopes: ScopesMap = {};
+
+    manifests.forEach((manifest) => {
+        if (!manifest.scopes) {
+            return;
+        }
+
+        Object.entries(manifest.scopes).forEach(([scopeName, specifierMap]) => {
+            const scopedImports: SpecifierMap = {};
+
+            Object.entries(specifierMap).forEach(
+                ([specifierName, identifier]) => {
+                    scopedImports[specifierName] =
+                        imports[identifier] ?? identifier;
+                }
+            );
+
+            const scopePath =
+                imports[`${manifest.name}/${scopeName}`] ?? `/${scopeName}`;
+
+            const scopeKey = getScope(manifest.name, scopePath);
+            scopes[scopeKey] = scopedImports;
+        });
+    });
+
+    return scopes;
+}
+
+export function getImportMap({
+    manifests,
+    getFile,
+    getScope
+}: GetImportMapOptions): ImportMap {
+    const imports = buildImportsMap(manifests, getFile);
+
+    const scopes = buildScopesMap(imports, manifests, getScope);
     return {
         imports,
         scopes