@softarc/native-federation-orchestrator 4.5.1 → 4.5.2

package/fesm2022/node.mjs

@@ -1868,13 +1868,15 @@ var createModeConfig = (override) => {
     strictExternalCompatibility: override.strict,
     strictExternalSameVersionCompatibility: override.strict,
     strictExternalVersion: override.strict,
-    strictImportMap: override.strict
+    strictImportMap: override.strict,
+    strictEntryPointCoverage: override.strict
   } : {
     strictRemoteEntry: override.strict?.strictRemoteEntry ?? false,
     strictExternalCompatibility: override.strict?.strictExternalCompatibility ?? false,
     strictExternalSameVersionCompatibility: override.strict?.strictExternalSameVersionCompatibility ?? false,
     strictExternalVersion: override.strict?.strictExternalVersion ?? false,
-    strictImportMap: override.strict?.strictImportMap ?? false
+    strictImportMap: override.strict?.strictImportMap ?? false,
+    strictEntryPointCoverage: override.strict?.strictEntryPointCoverage ?? false
   };
   return {
     strict: strictnessConfig,
@@ -2200,6 +2202,14 @@ function createDetermineSharedExternals(config, ports) {
     }
     return Promise.resolve();
   };
+  function uncoveredTears(external, winner) {
+    const basis = winner.remotes[0].entries;
+    return external.versions.reduce((sum, v) => {
+      if (v === winner) return sum;
+      if (!ports.versionCheck.isCompatible(winner.tag, v.remotes[0].requiredVersion)) return sum;
+      return sum + v.remotes.reduce((n, r) => n + Object.keys(r.entries).filter((e) => !(e in basis)).length, 0);
+    }, 0);
+  }
   function setVersionActions(externalName, external) {
     if (external.versions.length === 1) {
       external.versions[0].action = "share";
@@ -2212,12 +2222,15 @@ function createDetermineSharedExternals(config, ports) {
     }
     if (!sharedVersion) {
       let leastExtraDownloads = Number.MAX_VALUE;
+      let leastTears = Number.MAX_VALUE;
       external.versions.forEach((vA) => {
         const extraDownloads = external.versions.filter(
           (vB) => !vB.remotes[0].cached && vB.remotes[0].strictVersion && !ports.versionCheck.isCompatible(vA.tag, vB.remotes[0].requiredVersion)
         ).length;
-        if (extraDownloads < leastExtraDownloads) {
+        const tears = uncoveredTears(external, vA);
+        if (extraDownloads < leastExtraDownloads || extraDownloads === leastExtraDownloads && tears < leastTears) {
           leastExtraDownloads = extraDownloads;
+          leastTears = tears;
           sharedVersion = vA;
         }
       });
@@ -2240,6 +2253,22 @@ function createDetermineSharedExternals(config, ports) {
       v.action = v.remotes[0].strictVersion ? "scope" : "skip";
     });
     sharedVersion.action = "share";
+    if (config.strict.strictEntryPointCoverage) {
+      const basis = sharedVersion.remotes[0].entries;
+      external.versions.forEach((v) => {
+        if (v.action !== "skip") return;
+        const uncovered = v.remotes.some(
+          (r) => Object.keys(r.entries).some((entrypoint) => !(entrypoint in basis))
+        );
+        if (uncovered) {
+          v.action = "scope";
+          config.log.debug(
+            3,
+            `[${externalName}@${v.tag}] Scoped: entrypoints not covered by shared ${externalName}@${sharedVersion.tag}.`
+          );
+        }
+      });
+    }
     external.dirty = false;
     return external;
   }
@@ -2347,9 +2376,6 @@ function buildPools(sharedExternals, useAutoExternalPooling, log) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool.util.ts
-function versionForRemote(member, remote) {
-  return member.external.versions.find((v) => v.remotes.some((r) => r.name === remote));
-}
 function remotesInPool(members) {
   return [
     ...new Set(members.flatMap((m) => m.external.versions.flatMap((v) => v.remotes.map((r) => r.name))))
@@ -2357,57 +2383,12 @@ function remotesInPool(members) {
 }
 
 // src/lib/core/2.app/steps/pooling/pool-shared-externals.ts
-function poolWinners(members) {
-  return members.map((member) => {
-    const share = member.external.versions.find((v) => v.action === "share");
-    return {
-      member,
-      tag: share?.tag ?? "",
-      providers: new Set((share?.remotes ?? []).map((r) => r.name))
-    };
-  });
-}
-function selectCoverageAnchor(winners) {
-  const coverage = /* @__PURE__ */ new Map();
-  for (const winner of winners)
-    for (const remote of winner.providers) coverage.set(remote, (coverage.get(remote) ?? 0) + 1);
-  if (coverage.size === 0) return void 0;
-  const anchorRemote = [...coverage.keys()].sort(
-    (a, b) => coverage.get(b) - coverage.get(a) || a.localeCompare(b)
-  )[0];
-  return {
-    anchorRemote,
-    tagPerMember: Object.fromEntries(
-      winners.filter((w) => w.providers.has(anchorRemote)).map((w) => [w.member.name, w.tag])
-    )
-  };
-}
-function classifyPoolConservative(members, anchor) {
-  const classification = /* @__PURE__ */ new Map();
-  for (const remote of remotesInPool(members)) {
-    let coverageForced = false;
-    let verdict = "follow";
-    for (const member of members) {
-      const version = versionForRemote(member, remote);
-      if (!version) continue;
-      const anchorTag = anchor.tagPerMember[member.name];
-      if (!anchorTag) {
-        coverageForced = true;
-        continue;
-      }
-      if (version.tag === anchorTag) continue;
-      if (version.action === "scope") {
-        verdict = "scope-incompat";
-        break;
-      }
-    }
-    classification.set(
-      remote,
-      verdict === "scope-incompat" ? "scope-incompat" : coverageForced ? "scope-coverage" : "follow"
-    );
-  }
-  classification.set(anchor.anchorRemote, "follow");
-  return classification;
+function islandedRemotes(members) {
+  const islanded = /* @__PURE__ */ new Set();
+  for (const member of members)
+    for (const version of member.external.versions)
+      if (version.action === "scope") for (const remote of version.remotes) islanded.add(remote.name);
+  return islanded;
 }
 function createPoolSharedExternals(config, ports) {
   return () => {
@@ -2443,73 +2424,57 @@ function createPoolSharedExternals(config, ports) {
     if (members.length < 2) return;
     const allRemotes = remotesInPool(members);
     if (allRemotes.length < 2) return;
-    const anchor = selectCoverageAnchor(poolWinners(members));
-    if (!anchor) return;
-    const classification = classifyPoolConservative(members, anchor);
+    const islanded = islandedRemotes(members);
     config.log.debug(
       3,
-      `[${scope}][pool:${poolName}] members=[${members.map((m) => m.name).join(", ")}], anchor=${anchor.anchorRemote}, remotes={${allRemotes.map((r) => `${r}:${classification.get(r)}`).join(", ")}}`
+      `[${scope}][pool:${poolName}] ${members.length} members across ${allRemotes.length} remotes, islanded={${[...islanded].join(", ") || "\u2205"}}
+` + members.map((m) => `  - ${m.name}`).join("\n")
     );
-    const incompatForced = allRemotes.some((r) => classification.get(r) === "scope-incompat");
-    if (incompatForced && config.strict.strictExternalCompatibility) {
+    if (islanded.size > 0 && config.strict.strictExternalCompatibility) {
       config.log.error(
         3,
-        `[${scope}][pool:${poolName}] A remote is version-incompatible with anchor '${anchor.anchorRemote}'.`
+        `[${scope}][pool:${poolName}] version-incompatible remotes cannot be pooled: {${[...islanded].join(", ")}}.`
       );
       throw new NFError(`Could not pool '${poolName}' in scope ${scope}.`);
     }
     for (const member of members) {
-      const rebuilt = rebuildMember(member, anchor, classification);
+      const rebuilt = rebuildMember(member, islanded);
       warnIfScopedOnly(poolName, member.name, rebuilt, scope);
       ports.sharedExternalsRepo.addOrUpdate(member.name, rebuilt, scope);
     }
   }
   function warnIfScopedOnly(poolName, memberName, rebuilt, scope) {
     if (rebuilt.versions.some((v) => v.action === "share")) return;
-    const copies = rebuilt.versions.reduce((n, v) => n + v.remotes.length, 0);
+    const consumers = new Set(rebuilt.versions.flatMap((v) => v.remotes.map((r) => r.name))).size;
+    if (consumers < 2) return;
     config.log.warn(
       3,
-      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${copies} remotes download their own copy.`
+      `[${scope}][pool:${poolName}] '${memberName}' is scoped-only \u2014 no coherent shared build provides it; ${consumers} remotes download their own copy.`
     );
   }
-  function rebuildMember(member, anchor, classification) {
-    const anchorTag = anchor.tagPerMember[member.name];
+  function rebuildMember(member, islanded) {
     const entries = member.external.versions.flatMap(
-      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, meta }))
-    );
-    if (!anchorTag) {
-      return {
-        dirty: false,
-        versions: entries.length > 0 ? [
-          {
-            tag: entries[0].tag,
-            host: false,
-            action: "scope",
-            remotes: entries.map((e) => e.meta)
-          }
-        ] : []
-      };
-    }
-    const anchorMeta = entries.find(
-      (e) => e.remote === anchor.anchorRemote && e.tag === anchorTag
-    ).meta;
-    const anchorHost = member.external.versions.find((v) => v.tag === anchorTag)?.host ?? false;
-    const scopes = (e) => {
-      const cls = classification.get(e.remote);
-      return cls === "scope-incompat" || cls === "scope-coverage" && e.tag !== anchorTag;
-    };
-    const shareOnAnchor = entries.filter(
-      (e) => e.remote !== anchor.anchorRemote && e.tag === anchorTag && !scopes(e)
+      (v) => v.remotes.map((meta) => ({ remote: meta.name, tag: v.tag, host: v.host, action: v.action, meta }))
     );
-    const shareVersion = {
-      tag: anchorTag,
-      host: anchorHost,
-      action: "share",
-      remotes: [anchorMeta, ...shareOnAnchor.map((e) => e.meta)]
-    };
+    const isScoped = (e) => islanded.has(e.remote) || e.action === "scope";
+    let scoped = entries.filter(isScoped);
+    let clean = entries.filter((e) => !isScoped(e));
+    if (!clean.some((e) => e.action === "share")) {
+      scoped = [...scoped, ...clean];
+      clean = [];
+    }
+    const shareEntries = clean.filter((e) => e.action === "share");
+    const shareVersion = shareEntries.length > 0 ? [
+      {
+        tag: shareEntries[0].tag,
+        host: shareEntries[0].host,
+        action: "share",
+        remotes: shareEntries.map((e) => e.meta)
+      }
+    ] : [];
     const skipByTag = /* @__PURE__ */ new Map();
-    for (const e of entries) {
-      if (e.tag === anchorTag || scopes(e)) continue;
+    for (const e of clean) {
+      if (e.action !== "skip") continue;
       const version = skipByTag.get(e.tag) ?? {
         tag: e.tag,
         host: e.host,
@@ -2519,16 +2484,25 @@ function createPoolSharedExternals(config, ports) {
       version.remotes.push(e.meta);
       skipByTag.set(e.tag, version);
     }
-    const scoped = entries.filter((e) => scopes(e));
-    const scopeVersion = scoped.length > 0 ? [{ tag: anchorTag, host: false, action: "scope", remotes: scoped.map((e) => e.meta) }] : [];
+    const scopeByTag = /* @__PURE__ */ new Map();
+    for (const e of scoped) {
+      const version = scopeByTag.get(e.tag) ?? {
+        tag: e.tag,
+        host: false,
+        action: "scope",
+        remotes: []
+      };
+      version.remotes.push(e.meta);
+      scopeByTag.set(e.tag, version);
+    }
     return {
       dirty: false,
-      versions: [shareVersion, ...skipByTag.values(), ...scopeVersion]
+      versions: [...shareVersion, ...skipByTag.values(), ...scopeByTag.values()]
     };
   }
 }
 
-// node_modules/.pnpm/@softarc+native-federation@4.3.1_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
+// node_modules/.pnpm/@softarc+native-federation@4.3.2_typescript@6.0.3/node_modules/@softarc/native-federation/dist/lib/domain/core/chunk.js
 var CHUNK_PREFIX = "@nf-internal";
 function toChunkImport(fileName) {
   if (fileName.startsWith("./")) {
@@ -2635,6 +2609,17 @@ function createGenerateImportMap(config, ports) {
           for (const m of mappings) {
             addToScope(importMap, rScope, { [m.packageName]: m.url });
           }
+          for (const [packageName, file] of Object.entries(r.entries)) {
+            if (packageName in source.entries) continue;
+            if (config.strict.strictEntryPointCoverage) {
+              warnUncoveredEntrypoint(shareScope, externalName, r.name, packageName);
+              continue;
+            }
+            const url = join(rScope, file);
+            addToScope(importMap, rScope, { [packageName]: url });
+            addIntegrity(importMap, url, r.name, file);
+            r.cached = true;
+          }
         });
         for (const m of mappings) {
           addIntegrity(importMap, m.url, m.name, m.file);
@@ -2702,10 +2687,35 @@ function createGenerateImportMap(config, ports) {
         registerBundleChunks(chunkBundles, version.remotes[0].name, version.remotes[0].bundle);
         version.remotes[0].cached = true;
       }
+      for (const version of external.versions) {
+        if (version.action !== "skip") continue;
+        const remote = version.remotes[0];
+        for (const [packageName, file] of Object.entries(remote.entries)) {
+          if (importMap.imports[packageName]) continue;
+          if (config.strict.strictEntryPointCoverage) {
+            warnUncoveredEntrypoint(GLOBAL_SCOPE, externalName, remote.name, packageName);
+            continue;
+          }
+          const scope = getScope2(GLOBAL_SCOPE, remote.name, externalName);
+          const url = join(scope, file);
+          addToGlobal(importMap, { [packageName]: url });
+          addIntegrity(importMap, url, remote.name, file);
+          registerBundleChunks(chunkBundles, remote.name, remote.bundle);
+          remote.cached = true;
+        }
+      }
       ports.sharedExternalsRepo.addOrUpdate(externalName, external);
     }
     return importMap;
   }
+  function warnUncoveredEntrypoint(scope, externalName, remoteName, packageName) {
+    const msg = `[${scope}][${externalName}][${remoteName}] Entrypoint '${packageName}' is not covered by the shared version.`;
+    if (config.strict.strictImportMap) {
+      config.log.error(4, msg);
+      throw new NFError("Could not create ImportMap.");
+    }
+    config.log.warn(4, msg);
+  }
   function notifyDuplicateGlobalExternal(externalName) {
     if (config.strict.strictImportMap) {
       config.log.error(4, `[${externalName}] Shared external has multiple shared versions.`);
@@ -2928,6 +2938,9 @@ function createUpdateCache(config, ports) {
       }
       config.log.warn(8, errorMsg);
     }
+    if (action === "skip" && config.strict.strictEntryPointCoverage && sharedVersion && Object.keys(remote.entries).some((e) => !(e in sharedVersion.remotes[0].entries))) {
+      action = "scope";
+    }
     const matchingVersion = cached2.versions.find((cached3) => cached3.tag === tag);
     if (matchingVersion) {
       assertSameVersionCompatibility(matchingVersion);
@@ -2992,8 +3005,6 @@ function createPoolDynamicExternals(config) {
         const memberActions = members.map((name) => actions[name].action);
         if (memberActions.includes("scope")) {
           members.forEach(scope);
-        } else if (memberActions.includes("share") && memberActions.includes("skip")) {
-          members.filter((name) => actions[name].action === "share").forEach(scope);
         }
       }
     }
@@ -3042,6 +3053,16 @@ function createConvertToImportMap(config, ports) {
           Object.entries(override).forEach(([packageName, url]) => {
             addToScopes(remoteEntryScope, packageName, url, importMap);
           });
+          Object.entries(external.entries).forEach(([packageName, fileName]) => {
+            if (packageName in override) return;
+            if (config.strict.strictEntryPointCoverage) {
+              warnUncoveredEntrypoint(remoteEntry.name, external.packageName, packageName);
+              return;
+            }
+            const url = join(remoteEntryScope, fileName);
+            addToScopes(remoteEntryScope, packageName, url, importMap);
+            addIntegrity(importMap, url, integrityMap, fileName);
+          });
           return;
         }
         log.error(
@@ -3108,6 +3129,14 @@ function createConvertToImportMap(config, ports) {
     });
     return importMap;
   }
+  function warnUncoveredEntrypoint(remoteName, externalName, packageName) {
+    const msg = `[${remoteName}][${externalName}] Entrypoint '${packageName}' is not covered by the override.`;
+    if (config.strict.strictImportMap) {
+      log.error(9, msg);
+      throw new NFError("Could not create ImportMap.");
+    }
+    log.warn(9, msg);
+  }
   function addIntegrity(importMap, url, integrityMap, file) {
     const hash = integrityMap?.[file];
     if (!hash) return;