@softarc/native-federation-runtime 4.0.0-RC2 → 4.0.0-RC3

package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './lib/init-federation.js';
+export * from './lib/load-remote-module.js';
+export * from './lib/model/build-notifications-options.js';
+export * from './lib/model/federation-info.js';
+export * from './lib/model/import-map.js';

package/index.js

@@ -0,0 +1,336 @@
+// packages/runtime/src/lib/init-federation.ts
+import { toChunkImport } from "@softarc/native-federation/domain";
+
+// packages/runtime/src/lib/model/global-cache.ts
+var nfNamespace = "__NATIVE_FEDERATION__";
+var global = globalThis;
+global[nfNamespace] ??= {
+  externals: /* @__PURE__ */ new Map(),
+  remoteNamesToRemote: /* @__PURE__ */ new Map(),
+  baseUrlToRemoteNames: /* @__PURE__ */ new Map()
+};
+var globalCache = global[nfNamespace];
+
+// packages/runtime/src/lib/model/externals.ts
+var externals = globalCache.externals;
+function getExternalKey(shared) {
+  return `${shared.packageName}@${shared.version}`;
+}
+function getExternalUrl(shared) {
+  const packageKey = getExternalKey(shared);
+  return externals.get(packageKey);
+}
+function setExternalUrl(shared, url) {
+  const packageKey = getExternalKey(shared);
+  externals.set(packageKey, url);
+}
+
+// packages/runtime/src/lib/model/import-map.ts
+function mergeImportMaps(map1, map2) {
+  return {
+    imports: { ...map1.imports, ...map2.imports },
+    scopes: { ...map1.scopes, ...map2.scopes }
+  };
+}
+
+// packages/runtime/src/lib/model/remotes.ts
+var remoteNamesToRemote = globalCache.remoteNamesToRemote;
+var baseUrlToRemoteNames = globalCache.baseUrlToRemoteNames;
+function addRemote(remoteName, remote) {
+  remoteNamesToRemote.set(remoteName, remote);
+  baseUrlToRemoteNames.set(remote.baseUrl, remoteName);
+}
+function getRemoteNameByBaseUrl(baseUrl) {
+  return baseUrlToRemoteNames.get(baseUrl);
+}
+function isRemoteInitialized(baseUrl) {
+  return baseUrlToRemoteNames.has(baseUrl);
+}
+function getRemote(remoteName) {
+  return remoteNamesToRemote.get(remoteName);
+}
+
+// packages/runtime/src/lib/utils/trusted-types.ts
+var global2 = globalThis;
+var policy;
+function createPolicy() {
+  if (policy === void 0) {
+    policy = null;
+    if (global2.trustedTypes) {
+      try {
+        policy = global2.trustedTypes.createPolicy(
+          "native-federation",
+          {
+            createHTML: (html) => html,
+            createScript: (script) => script,
+            createScriptURL: (url) => url
+          }
+        );
+      } catch {
+      }
+    }
+  }
+  return policy;
+}
+function tryCreateTrustedScript(script) {
+  return createPolicy()?.createScript(script) ?? script;
+}
+
+// packages/runtime/src/lib/utils/add-import-map.ts
+function appendImportMap(importMap) {
+  document.head.appendChild(
+    Object.assign(document.createElement("script"), {
+      type: tryCreateTrustedScript("importmap-shim"),
+      textContent: tryCreateTrustedScript(JSON.stringify(importMap))
+    })
+  );
+}
+
+// packages/runtime/src/lib/utils/path-utils.ts
+function getDirectory(url) {
+  const parts = url.split("/");
+  parts.pop();
+  return parts.join("/");
+}
+function joinPaths(path1, path2) {
+  while (path1.endsWith("/")) {
+    path1 = path1.substring(0, path1.length - 1);
+  }
+  if (path2.startsWith("./")) {
+    path2 = path2.substring(2, path2.length);
+  }
+  return `${path1}/${path2}`;
+}
+
+// packages/runtime/src/lib/watch-federation-build.ts
+import { BuildNotificationType } from "@softarc/native-federation/domain";
+function watchFederationBuildCompletion(endpoint) {
+  const eventSource = new EventSource(endpoint);
+  eventSource.onmessage = function(event) {
+    const data = JSON.parse(event.data);
+    if (data.type === BuildNotificationType.COMPLETED) {
+      console.log("[Federation] Rebuild completed, reloading...");
+      window.location.reload();
+    }
+  };
+  eventSource.onerror = function(event) {
+    console.warn("[Federation] SSE connection error:", event);
+  };
+}
+
+// packages/runtime/src/lib/init-federation.ts
+async function initFederation(remotesOrManifestUrl = {}, options) {
+  const cacheTag = options?.cacheTag ? `?t=${options.cacheTag}` : "";
+  const normalizedRemotes = typeof remotesOrManifestUrl === "string" ? await loadManifest(remotesOrManifestUrl + cacheTag) : remotesOrManifestUrl;
+  const hostInfo = await loadFederationInfo(`./remoteEntry.json${cacheTag}`);
+  const hostImportMap = await processHostInfo(hostInfo);
+  const remotesImportMap = await fetchAndRegisterRemotes(normalizedRemotes, {
+    throwIfRemoteNotFound: false,
+    ...options
+  });
+  const mergedImportMap = mergeImportMaps(hostImportMap, remotesImportMap);
+  appendImportMap(mergedImportMap);
+  return mergedImportMap;
+}
+async function loadManifest(manifestUrl) {
+  const manifest = await fetch(manifestUrl).then((r) => r.json());
+  return manifest;
+}
+function applyCacheTag(url, cacheTag) {
+  if (!cacheTag) return url;
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}t=${cacheTag}`;
+}
+function handleRemoteLoadError(remoteName, remoteUrl, options, originalError) {
+  const errorMessage = `Error loading remote entry for ${remoteName} from file ${remoteUrl}`;
+  if (options.throwIfRemoteNotFound) {
+    throw new Error(errorMessage);
+  }
+  console.error(errorMessage);
+  console.error(originalError);
+  return null;
+}
+async function fetchAndRegisterRemotes(remotes, options = { throwIfRemoteNotFound: false }) {
+  const fetchAndRegisterRemotePromises = Object.entries(remotes).map(
+    async ([remoteName, remoteUrl]) => {
+      try {
+        const urlWithCache = applyCacheTag(remoteUrl, options.cacheTag);
+        return await fetchAndRegisterRemote(urlWithCache, remoteName);
+      } catch (e) {
+        return handleRemoteLoadError(remoteName, remoteUrl, options, e);
+      }
+    }
+  );
+  const remoteImportMaps = await Promise.all(fetchAndRegisterRemotePromises);
+  const importMap = remoteImportMaps.reduce(
+    (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc,
+    { imports: {}, scopes: {} }
+  );
+  return importMap;
+}
+async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) {
+  return fetchAndRegisterRemotes(remotes, options);
+}
+async function fetchAndRegisterRemote(federationInfoUrl, remoteName) {
+  const baseUrl = getDirectory(federationInfoUrl);
+  const remoteInfo = await loadFederationInfo(federationInfoUrl);
+  if (!remoteName) {
+    remoteName = remoteInfo.name;
+  }
+  if (remoteInfo.buildNotificationsEndpoint) {
+    watchFederationBuildCompletion(baseUrl + remoteInfo.buildNotificationsEndpoint);
+  }
+  const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl);
+  addRemote(remoteName, { ...remoteInfo, baseUrl });
+  return importMap;
+}
+function createRemoteImportMap(remoteInfo, remoteName, baseUrl) {
+  const imports = processExposed(remoteInfo, remoteName, baseUrl);
+  const scopes = processRemoteImports(remoteInfo, baseUrl);
+  return { imports, scopes };
+}
+async function loadFederationInfo(remoteEntryUrl) {
+  const info = await fetch(remoteEntryUrl).then((r) => r.json());
+  return info;
+}
+function processRemoteImports(remoteInfo, baseUrl) {
+  const scopes = {};
+  const scopedImports = {};
+  for (const shared of remoteInfo.shared) {
+    const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName);
+    setExternalUrl(shared, outFileName);
+    scopedImports[shared.packageName] = outFileName;
+  }
+  if (remoteInfo.chunks) {
+    Object.values(remoteInfo.chunks).forEach((c) => {
+      c.forEach((e) => {
+        const key = toChunkImport(e);
+        scopedImports[key] = joinPaths(baseUrl, e);
+      });
+    });
+  }
+  scopes[baseUrl + "/"] = scopedImports;
+  return scopes;
+}
+function processExposed(remoteInfo, remoteName, baseUrl) {
+  const imports = {};
+  for (const exposed of remoteInfo.exposes) {
+    const key = joinPaths(remoteName, exposed.key);
+    const value = joinPaths(baseUrl, exposed.outFileName);
+    imports[key] = value;
+  }
+  return imports;
+}
+async function processHostInfo(hostInfo, relBundlesPath = "./") {
+  const imports = hostInfo.shared.reduce(
+    (acc, cur) => ({
+      ...acc,
+      [cur.packageName]: relBundlesPath + cur.outFileName
+    }),
+    {}
+  );
+  if (hostInfo.chunks) {
+    Object.values(hostInfo.chunks).forEach((c) => {
+      c.forEach((e) => {
+        const key = toChunkImport(e);
+        imports[key] = relBundlesPath + e;
+      });
+    });
+  }
+  for (const shared of hostInfo.shared) {
+    setExternalUrl(shared, relBundlesPath + shared.outFileName);
+  }
+  return { imports, scopes: {} };
+}
+
+// packages/runtime/src/lib/load-remote-module.ts
+async function loadRemoteModule(optionsOrRemoteName, exposedModule) {
+  const options = normalizeOptions(optionsOrRemoteName, exposedModule);
+  await ensureRemoteInitialized(options);
+  const remoteName = getRemoteNameByOptions(options);
+  const remote = getRemote(remoteName);
+  const fallback = options.fallback;
+  const remoteError = !remote ? "unknown remote " + remoteName : "";
+  if (!remote && !fallback) throw new Error(remoteError);
+  if (!remote) {
+    logClientError(remoteError);
+    return Promise.resolve(fallback);
+  }
+  const exposedModuleInfo = remote.exposes.find((e) => e.key === options.exposedModule);
+  const exposedError = !exposedModuleInfo ? `Unknown exposed module ${options.exposedModule} in remote ${remoteName}` : "";
+  if (!exposedModuleInfo && !fallback) throw new Error(exposedError);
+  if (!exposedModuleInfo) {
+    logClientError(exposedError);
+    return Promise.resolve(fallback);
+  }
+  const moduleUrl = joinPaths(remote.baseUrl, exposedModuleInfo.outFileName);
+  try {
+    const module = _import(moduleUrl);
+    return module;
+  } catch (e) {
+    if (fallback) {
+      console.error("error loading remote module", e);
+      return fallback;
+    }
+    throw e;
+  }
+}
+function _import(moduleUrl) {
+  return typeof importShim !== "undefined" ? importShim(moduleUrl) : import(
+    /* @vite-ignore */
+    moduleUrl
+  );
+}
+function getRemoteNameByOptions(options) {
+  let remoteName;
+  if (options.remoteName) {
+    remoteName = options.remoteName;
+  } else if (options.remoteEntry) {
+    const baseUrl = getDirectory(options.remoteEntry);
+    remoteName = getRemoteNameByBaseUrl(baseUrl);
+  } else {
+    throw new Error("unexpected arguments: Please pass remoteName or remoteEntry");
+  }
+  if (!remoteName) {
+    throw new Error("unknown remoteName " + remoteName);
+  }
+  return remoteName;
+}
+async function ensureRemoteInitialized(options) {
+  if (options.remoteEntry && !isRemoteInitialized(getDirectory(options.remoteEntry))) {
+    const importMap = await fetchAndRegisterRemote(options.remoteEntry);
+    appendImportMap(importMap);
+  }
+}
+function normalizeOptions(optionsOrRemoteName, exposedModule) {
+  let options;
+  if (typeof optionsOrRemoteName === "string" && exposedModule) {
+    options = {
+      remoteName: optionsOrRemoteName,
+      exposedModule
+    };
+  } else if (typeof optionsOrRemoteName === "object" && !exposedModule) {
+    options = optionsOrRemoteName;
+  } else {
+    throw new Error("unexpected arguments: please pass options or a remoteName/exposedModule-pair");
+  }
+  return options;
+}
+function logClientError(error) {
+  if (typeof window !== "undefined") {
+    console.error(error);
+  }
+}
+
+// packages/runtime/src/lib/model/build-notifications-options.ts
+var BUILD_NOTIFICATIONS_ENDPOINT = "/@angular-architects/native-federation:build-notifications";
+export {
+  BUILD_NOTIFICATIONS_ENDPOINT,
+  fetchAndRegisterRemote,
+  fetchAndRegisterRemotes,
+  initFederation,
+  loadRemoteModule,
+  mergeImportMaps,
+  processHostInfo,
+  processRemoteInfos
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation-runtime",
-  "version": "4.0.0-RC2",
+  "version": "4.0.0-RC3",
   "type": "module",
   "license": "MIT",
   "main": "./index.js",
@@ -16,8 +16,13 @@
   },
   "files": [
     "lib",
+    "index.d.ts",
+    "index.js",
     "!**/*.tsbuildinfo"
   ],
+  "dependencies": {
+    "@softarc/native-federation": "4.0.0-RC3"
+  },
   "devDependencies": {
     "@types/node": "^22.5.4",
     "vitest": "^3.0.0",