@softarc/native-federation-orchestrator 4.0.0-RC1 → 4.0.0-RC3

package/fesm2022/@softarc/native-federation-orchestrator.mjs

@@ -1281,7 +1281,7 @@ function createGetRemoteEntries(config, ports) {
   return (remotesOrManifestUrl = {}) => ports.manifestProvider.provide(remotesOrManifestUrl).catch((e) => {
     config.log.error(1, "Could not fetch manifest.", e);
     return Promise.reject(new NFError("Failed to fetch manifest"));
-  }).then(addHostRemoteEntry).then(fetchRemoteEntries).then(removeSkippedRemotes);
+  }).then(addHostRemoteEntry).then(fetchRemoteEntries).then(removeSkippedRemotes).then(checkForSSE);
   function addHostRemoteEntry(manifest) {
     if (!config.hostRemoteEntry) return manifest;
     const { name, url, cacheTag } = config.hostRemoteEntry;
@@ -1344,6 +1344,21 @@ function createGetRemoteEntries(config, ports) {
   function removeSkippedRemotes(remoteEntries) {
     return remoteEntries.filter((entry) => entry !== false);
   }
+  function checkForSSE(remoteEntries) {
+    if (config.sse) {
+      remoteEntries.forEach((entry) => {
+        if (entry.buildNotificationsEndpoint) {
+          ports.sse.watchRemoteBuilds(
+            join(getScope(entry.url), entry.buildNotificationsEndpoint)
+          );
+          config.log.debug(1, `Registered SSE endpoint of remote '${entry.name}' `);
+          return;
+        }
+        config.log.debug(1, `Remote ${entry.name} has no defined 'buildNotificationsEndpoint'`);
+      });
+    }
+    return remoteEntries;
+  }
 }
 
 // src/lib/2.app/flows/init/process-remote-entries.ts
@@ -1354,6 +1369,7 @@ function createProcessRemoteEntries(config, ports) {
         if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
         addRemoteInfoToStorage(remoteEntry);
         addExternalsToStorage(remoteEntry);
+        addSharedChunksToStorage(remoteEntry);
       });
       return Promise.resolve(remoteEntries);
     } catch (e) {
@@ -1391,12 +1407,23 @@ function createProcessRemoteEntries(config, ports) {
       }
     });
   }
+  function addSharedChunksToStorage(remoteEntry) {
+    if (!remoteEntry.chunks) return;
+    config.log.debug(
+      2,
+      `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
+    );
+    Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
+      ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
+    });
+  }
   function addSharedExternal(remoteName, sharedInfo, remoteEntry) {
     let action = "skip";
     const tag = sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion);
     const remote = {
       file: sharedInfo.outFileName,
       name: remoteName,
+      bundle: sharedInfo.bundle,
       strictVersion: sharedInfo.strictVersion,
       cached: false,
       requiredVersion: sharedInfo.requiredVersion || tag
@@ -1438,7 +1465,8 @@ function createProcessRemoteEntries(config, ports) {
   function addScopedExternal(scope, sharedInfo) {
     ports.scopedExternalsRepo.addExternal(scope, sharedInfo.packageName, {
       tag: sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion),
-      file: sharedInfo.outFileName
+      file: sharedInfo.outFileName,
+      bundle: sharedInfo.bundle
     });
   }
 }
@@ -1524,21 +1552,41 @@ function createDetermineSharedExternals(config, ports) {
   }
 }
 
+// node_modules/.pnpm/@softarc+native-federation@4.0.0-RC3_typescript@5.9.3_47bb4de43df406d114d8f653e70c5696/node_modules/@softarc/native-federation/src/lib/domain/core/build-notification-options.contract.js
+var BuildNotificationType;
+(function(BuildNotificationType2) {
+  BuildNotificationType2["COMPLETED"] = "federation-rebuild-complete";
+  BuildNotificationType2["ERROR"] = "federation-rebuild-error";
+  BuildNotificationType2["CANCELLED"] = "federation-rebuild-cancelled";
+})(BuildNotificationType || (BuildNotificationType = {}));
+
+// node_modules/.pnpm/@softarc+native-federation@4.0.0-RC3_typescript@5.9.3_47bb4de43df406d114d8f653e70c5696/node_modules/@softarc/native-federation/src/lib/domain/core/chunk.js
+var CHUNK_PREFIX = "@nf-internal";
+function toChunkImport(fileName) {
+  if (fileName.startsWith("./")) {
+    fileName = fileName.slice(2);
+  }
+  const packageName = fileName.replace(/.(m|c)?js$/, "");
+  return CHUNK_PREFIX + "/" + packageName;
+}
+
 // src/lib/2.app/flows/init/generate-import-map.ts
 function createGenerateImportMap(config, ports) {
   return () => {
     const importMap = { imports: {} };
+    const chunkBundles = {};
     try {
-      addScopedExternals(importMap);
-      addshareScopeExternals(importMap);
-      addGlobalSharedExternals(importMap);
+      addScopedExternals(importMap, chunkBundles);
+      addshareScopeExternals(importMap, chunkBundles);
+      addGlobalSharedExternals(importMap, chunkBundles);
+      addChunkImports(importMap, chunkBundles);
       addRemoteInfos(importMap);
       return Promise.resolve(importMap);
     } catch (e) {
       return Promise.reject(e);
     }
   };
-  function addScopedExternals(importMap) {
+  function addScopedExternals(importMap, chunkBundles) {
     const scopedExternals = ports.scopedExternalsRepo.getAll();
     for (const [remoteName, externals] of Object.entries(scopedExternals)) {
       const remote = ports.remoteInfoRepo.tryGet(remoteName).orThrow(() => {
@@ -1546,6 +1594,7 @@ function createGenerateImportMap(config, ports) {
         return new NFError("Could not create ImportMap.");
       });
       addToScope(importMap, remote.scopeUrl, createScopeModules(externals, remote.scopeUrl));
+      Object.values(externals).filter((e) => !!e.bundle).forEach((e) => registerBundleChunks(chunkBundles, remoteName, e.bundle));
     }
     return importMap;
   }
@@ -1556,14 +1605,14 @@ function createGenerateImportMap(config, ports) {
     }
     return modules;
   }
-  function addshareScopeExternals(importMap) {
+  function addshareScopeExternals(importMap, chunkBundles) {
     const shareScopes = ports.sharedExternalsRepo.getScopes({ includeGlobal: false });
     for (const shareScope of shareScopes) {
-      processshareScope(importMap, shareScope);
+      processshareScope(importMap, shareScope, chunkBundles);
     }
     return importMap;
   }
-  function processshareScope(importMap, shareScope) {
+  function processshareScope(importMap, shareScope, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope(shareScope);
     for (const [externalName, external] of Object.entries(sharedExternals)) {
       let override = void 0;
@@ -1571,15 +1620,16 @@ function createGenerateImportMap(config, ports) {
       for (const version of external.versions) {
         if (version.action === "scope") {
           for (const remote of version.remotes) {
-            const remoteScope = getScope2(externalName, shareScope, remote.name);
+            const remoteScope = getScope2(shareScope, remote.name, externalName);
             addToScope(importMap, remoteScope, {
               [externalName]: join(remoteScope, remote.file)
             });
+            registerBundleChunks(chunkBundles, remote.name, remote.bundle);
             remote.cached = true;
           }
           continue;
         }
-        const scope = getScope2(externalName, shareScope, version.remotes[0].name);
+        const scope = getScope2(shareScope, version.remotes[0].name, externalName);
         let targetFileUrl = join(scope, version.remotes[0].file);
         version.remotes[0].cached = true;
         if (version.action === "skip") {
@@ -1588,14 +1638,14 @@ function createGenerateImportMap(config, ports) {
           }
           if (override !== "NOT_AVAILABLE") {
             if (!overrideScope)
-              overrideScope = getScope2(externalName, shareScope, override.remotes[0].name);
+              overrideScope = getScope2(shareScope, override.remotes[0].name, externalName);
             targetFileUrl = join(overrideScope, override.remotes[0].file);
             override.remotes[0].cached = true;
             version.remotes[0].cached = false;
           }
         }
         version.remotes.forEach((r) => {
-          const scope2 = getScope2(externalName, shareScope, r.name);
+          const scope2 = getScope2(shareScope, r.name, externalName);
           addToScope(importMap, scope2, { [externalName]: targetFileUrl });
         });
       }
@@ -1630,34 +1680,36 @@ function createGenerateImportMap(config, ports) {
     }
     config.log.warn(4, `ShareScope external ${scopedExternalName} has multiple shared versions.`);
   }
-  function addGlobalSharedExternals(importMap) {
+  function addGlobalSharedExternals(importMap, chunkBundles) {
     const sharedExternals = ports.sharedExternalsRepo.getFromScope();
     for (const [externalName, external] of Object.entries(sharedExternals)) {
       for (const version of external.versions) {
         if (version.action === "skip") continue;
         if (version.action === "scope") {
           for (const remote of version.remotes) {
-            const remoteScope = getScope2(externalName, GLOBAL_SCOPE, remote.name);
+            const remoteScope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
             addToScope(importMap, remoteScope, {
               [externalName]: join(remoteScope, remote.file)
             });
             remote.cached = true;
+            registerBundleChunks(chunkBundles, remote.name, remote.bundle);
           }
           continue;
         }
         if (importMap.imports[externalName]) {
-          handleDuplicateGlobalExternal(externalName);
+          notifyDuplicateGlobalExternal(externalName);
           continue;
         }
-        const scope = getScope2(externalName, GLOBAL_SCOPE, version.remotes[0].name);
+        const scope = getScope2(GLOBAL_SCOPE, version.remotes[0].name, externalName);
         addToGlobal(importMap, { [externalName]: join(scope, version.remotes[0].file) });
+        registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
         version.remotes[0].cached = true;
       }
       ports.sharedExternalsRepo.addOrUpdate(externalName, external);
     }
     return importMap;
   }
-  function handleDuplicateGlobalExternal(externalName) {
+  function notifyDuplicateGlobalExternal(externalName) {
     if (config.strict.strictImportMap) {
       config.log.error(4, `[${externalName}] Shared external has multiple shared versions.`);
       throw new NFError("Could not create ImportMap.");
@@ -1685,12 +1737,37 @@ function createGenerateImportMap(config, ports) {
       importMap.imports[moduleName] = moduleUrl;
     }
   }
-  function getScope2(externalName, shareScope, remoteName) {
+  function registerBundleChunks(chunkBundles, remoteName, bundleName) {
+    if (!bundleName) return chunkBundles;
+    if (!chunkBundles[remoteName]) chunkBundles[remoteName] = /* @__PURE__ */ new Set();
+    chunkBundles[remoteName].add(bundleName);
+    return chunkBundles;
+  }
+  function addChunkImports(importMap, chunkBundles) {
+    const chunkImports = Object.entries(chunkBundles).reduce((imports, [remoteName, bundles]) => {
+      const baseUrl = getScope2("CHUNKS", remoteName);
+      Array.from(bundles).forEach((bundleName) => {
+        ports.sharedChunksRepo.tryGet(remoteName, bundleName).ifPresent((files) => {
+          files.forEach((file) => {
+            imports[toChunkImport(file)] = join(baseUrl, file);
+          });
+        });
+      });
+      return imports;
+    }, {});
+    addToGlobal(importMap, chunkImports);
+    return importMap;
+  }
+  function getScope2(ctx, remoteName, externalName) {
     return ports.remoteInfoRepo.tryGet(remoteName).map((remote) => remote.scopeUrl).orThrow(() => {
-      config.log.error(
-        4,
-        `[${shareScope}][${externalName}][${remoteName}] Remote name not found in cache.`
-      );
+      if (externalName) {
+        config.log.error(
+          4,
+          `[${ctx}][${externalName}][${remoteName}] Remote name not found in cache.`
+        );
+      } else {
+        config.log.error(4, `[${ctx}][${remoteName}] Remote name not found in cache.`);
+      }
       return new NFError("Could not create ImportMap.");
     });
   }
@@ -1708,6 +1785,7 @@ function createCommitChanges(config, ports) {
     ports.remoteInfoRepo.commit();
     ports.scopedExternalsRepo.commit();
     ports.sharedExternalsRepo.commit();
+    ports.sharedChunksRepo.commit();
     return;
   }
 }
@@ -2016,6 +2094,68 @@ var createSharedExternalsRepository = (config) => {
   };
 };
 
+// src/lib/3.adapters/browser/sse-handler.ts
+var createSSEHandler = (config) => {
+  const subscribers = [];
+  return {
+    watchRemoteBuilds: function(endpoint) {
+      const eventSource = new EventSource(endpoint);
+      eventSource.onmessage = function(event) {
+        const data = JSON.parse(event.data);
+        if (data.type === BuildNotificationType.COMPLETED) {
+          subscribers.forEach((sub) => sub.close());
+          config.log.debug(0, "[SSE] Rebuild completed, reloading...");
+          config.reloadBrowserFn();
+        }
+      };
+      eventSource.onerror = function(event) {
+        config.log.error(0, "[SSE] Connection error:", event);
+      };
+      subscribers.push(eventSource);
+    },
+    closeAll: function() {
+      subscribers.forEach((sub) => sub.close());
+      subscribers.length = 0;
+    }
+  };
+};
+
+// src/lib/utils/clone-entry.ts
+var cloneEntry = (name, raw) => {
+  try {
+    if (typeof structuredClone === "function") {
+      return structuredClone(raw);
+    }
+  } catch {
+  }
+  try {
+    return JSON.parse(JSON.stringify(raw));
+  } catch {
+  }
+  throw new NFError(`Could not parse storage entry '${String(name)}'`);
+};
+
+// src/lib/3.adapters/storage/chunk.repository.ts
+var createChunkRepository = (config) => {
+  const STORAGE = config.storage("shared-chunks", {});
+  if (config.clearStorage) STORAGE.clear();
+  const _cache = STORAGE.get() ?? {};
+  return {
+    addOrReplace: function(remoteName, bundleName, chunks) {
+      if (!_cache[remoteName]) _cache[remoteName] = {};
+      _cache[remoteName][bundleName] = chunks;
+      return this;
+    },
+    tryGet: function(remoteName, bundleName) {
+      return Optional.of(_cache[remoteName]?.[bundleName]);
+    },
+    commit: function() {
+      STORAGE.set(_cache);
+      return this;
+    }
+  };
+};
+
 // src/lib/5.di/driving.factory.ts
 var createDriving = (config) => {
   const adapters = {
@@ -2025,7 +2165,9 @@ var createDriving = (config) => {
     remoteInfoRepo: createRemoteInfoRepository(config),
     scopedExternalsRepo: createScopedExternalsRepository(config),
     sharedExternalsRepo: createSharedExternalsRepository(config),
-    browser: createBrowser(config)
+    sharedChunksRepo: createChunkRepository(config),
+    browser: createBrowser(config),
+    sse: createSSEHandler(config)
   };
   return { adapters, config };
 };
@@ -2050,7 +2192,10 @@ var useDefaultImportMap = () => ({
     /* @vite-ignore */
     url
   ),
-  setImportMapFn: replaceInDOM("importmap")
+  setImportMapFn: replaceInDOM("importmap"),
+  reloadBrowserFn: () => {
+    window.location.reload();
+  }
 });
 
 // src/lib/4.config/import-map/import-map.config.ts
@@ -2058,7 +2203,8 @@ var createImportMapConfig = (o) => {
   const fallback = useDefaultImportMap();
   return {
     setImportMapFn: o.setImportMapFn ?? fallback.setImportMapFn,
-    loadModuleFn: o.loadModuleFn ?? fallback.loadModuleFn
+    loadModuleFn: o.loadModuleFn ?? fallback.loadModuleFn,
+    reloadBrowserFn: o.reloadBrowserFn ?? fallback.reloadBrowserFn
   };
 };
 
@@ -2119,25 +2265,11 @@ var createLogHandler = (logger, logLevel) => {
 };
 
 // src/lib/4.config/logging/log.config.ts
-var createLogConfig = ({ logger, logLevel }) => ({
-  log: createLogHandler(logger ?? noopLogger, logLevel ?? "error")
+var createLogConfig = ({ logger, logLevel, sse }) => ({
+  log: createLogHandler(logger ?? noopLogger, logLevel ?? "error"),
+  sse: !!sse
 });
 
-// src/lib/utils/clone-entry.ts
-var cloneEntry = (name, raw) => {
-  try {
-    if (typeof structuredClone === "function") {
-      return structuredClone(raw);
-    }
-  } catch {
-  }
-  try {
-    return JSON.parse(JSON.stringify(raw));
-  } catch {
-  }
-  throw new NFError(`Could not parse storage entry '${String(name)}'`);
-};
-
 // src/lib/4.config/storage/global-this.storage.ts
 var globalThisStorageEntry = (namespace) => (key, initialValue) => {
   if (!globalThis[namespace]) {
@@ -2203,7 +2335,7 @@ var createConfigHandlers = (overrides) => ({
 });
 
 // src/lib/2.app/flows/dynamic-init/convert-to-import-map.ts
-function createConvertToImportMap({ log }) {
+function createConvertToImportMap({ log }, ports) {
   return ({ entry, actions }) => {
     const importMap = { imports: {} };
     addExternals(entry, actions, importMap);
@@ -2216,6 +2348,7 @@ function createConvertToImportMap({ log }) {
       return;
     }
     const remoteEntryScope = getScope(remoteEntry.url);
+    const chunkBundles = /* @__PURE__ */ new Set();
     remoteEntry.shared.forEach((external) => {
       if (!external.singleton) {
         addToScopes(
@@ -2224,6 +2357,7 @@ function createConvertToImportMap({ log }) {
           join(remoteEntryScope, external.outFileName),
           importMap
         );
+        if (external?.bundle) chunkBundles.add(external?.bundle);
         return;
       }
       if (!actions[external.packageName]) {
@@ -2245,6 +2379,7 @@ function createConvertToImportMap({ log }) {
           return;
         }
       }
+      if (external?.bundle) chunkBundles.add(external?.bundle);
       if (actions[external.packageName].action === "scope") {
         addToScopes(
           remoteEntryScope,
@@ -2265,6 +2400,7 @@ function createConvertToImportMap({ log }) {
       }
       importMap.imports[external.packageName] = join(remoteEntryScope, external.outFileName);
     });
+    addChunkImports(importMap, remoteEntry.name, remoteEntryScope, chunkBundles);
   }
   function addToScopes(scope, packageName, url, importMap) {
     if (!importMap.scopes) importMap.scopes = {};
@@ -2280,6 +2416,18 @@ function createConvertToImportMap({ log }) {
       importMap.imports[moduleName] = moduleUrl;
     });
   }
+  function addChunkImports(importMap, remoteName, baseUrl, chunkBundles) {
+    const chunkImports = Array.from(chunkBundles).reduce((imports, bundleName) => {
+      ports.sharedChunksRepo.tryGet(remoteName, bundleName).ifPresent((files) => {
+        files.forEach((file) => {
+          imports[toChunkImport(file)] = join(baseUrl, file);
+        });
+      });
+      return imports;
+    }, {});
+    importMap.imports = { ...importMap.imports, ...chunkImports };
+    return importMap;
+  }
 }
 
 // src/lib/2.app/flows/dynamic-init/get-remote-entry.ts
@@ -2307,7 +2455,7 @@ function createGetRemoteEntry(config, ports) {
         remoteEntry.override = true;
         config.log.debug(7, `Overriding existing remote '${remoteName}' with '${remoteEntryUrl}'.`);
       }
-      return Optional.of(remoteEntry);
+      return Optional.of(checkForSSE(remoteEntry));
     } catch (error) {
       config.log.error(
         7,
@@ -2324,6 +2472,19 @@ function createGetRemoteEntry(config, ports) {
       (cachedRemoteInfo) => config.profile.overrideCachedRemotes !== "always" || !config.profile.overrideCachedRemotesIfURLMatches && remoteEntryUrl === join(cachedRemoteInfo.scopeUrl, "remoteEntry.json")
     ).orElse(false);
   }
+  function checkForSSE(entry) {
+    if (config.sse) {
+      if (entry.buildNotificationsEndpoint) {
+        ports.sse.watchRemoteBuilds(
+          join(getScope(entry.url), entry.buildNotificationsEndpoint)
+        );
+        config.log.debug(7, `Registered SSE endpoint of remote '${entry.name}' `);
+      } else {
+        config.log.debug(7, `Remote ${entry.name} has no defined 'buildNotificationsEndpoint'`);
+      }
+    }
+    return entry;
+  }
 }
 
 // src/lib/2.app/flows/dynamic-init/update-cache.ts
@@ -2333,6 +2494,7 @@ function createUpdateCache(config, ports) {
       if (remoteEntry?.override) removeCachedRemoteEntry(remoteEntry);
       addRemoteInfoToStorage(remoteEntry);
       const actions = mergeExternalsIntoStorage(remoteEntry);
+      addSharedChunksToStorage(remoteEntry);
       return Promise.resolve({ entry: remoteEntry, actions });
     } catch (error) {
       return Promise.reject(error);
@@ -2383,6 +2545,16 @@ function createUpdateCache(config, ports) {
     });
     return actions;
   }
+  function addSharedChunksToStorage(remoteEntry) {
+    if (!remoteEntry.chunks) return;
+    config.log.debug(
+      8,
+      `Adding chunks for remote "${remoteEntry.name}", bundles: [${Object.keys(remoteEntry.chunks).join(", ")}]`
+    );
+    Object.entries(remoteEntry.chunks).forEach(([bundleName, chunks]) => {
+      ports.sharedChunksRepo.addOrReplace(remoteEntry.name, bundleName, chunks);
+    });
+  }
   function addSharedExternal(remoteName, sharedInfo) {
     const cached = ports.sharedExternalsRepo.tryGet(sharedInfo.packageName, sharedInfo.shareScope).orElse({ dirty: false, versions: [] });
     let action = "skip";
@@ -2392,6 +2564,7 @@ function createUpdateCache(config, ports) {
       strictVersion: sharedInfo.strictVersion,
       requiredVersion: sharedInfo.requiredVersion || tag,
       name: remoteName,
+      bundle: sharedInfo.bundle,
       cached: false
     };
     const scopeType = ports.sharedExternalsRepo.scopeType(sharedInfo.shareScope);
@@ -2439,7 +2612,8 @@ function createUpdateCache(config, ports) {
   function addScopedExternal(remoteName, sharedInfo) {
     ports.scopedExternalsRepo.addExternal(remoteName, sharedInfo.packageName, {
       tag: sharedInfo.version ?? ports.versionCheck.smallestVersion(sharedInfo.requiredVersion),
-      file: sharedInfo.outFileName
+      file: sharedInfo.outFileName,
+      bundle: sharedInfo.bundle
     });
   }
 }
@@ -2451,7 +2625,7 @@ var createDynamicInitDrivers = ({
 }) => ({
   getRemoteEntry: createGetRemoteEntry(config, adapters),
   updateCache: createUpdateCache(config, adapters),
-  convertToImportMap: createConvertToImportMap(config),
+  convertToImportMap: createConvertToImportMap(config, adapters),
   commitChanges: createCommitChanges(config, adapters)
 });
 var DYNAMIC_INIT_FLOW_FACTORY = ({