@softarc/native-federation-runtime 3.5.0 → 4.0.0-RC1

package/README.md

@@ -1,7 +1,11 @@
-# native-federation-runtime
+# runtime
 
 This library was generated with [Nx](https://nx.dev).
 
+## Building
+
+Run `nx build runtime` to build the library.
+
 ## Running unit tests
 
-Run `nx test native-federation-runtime` to execute the unit tests.
+Run `nx test runtime` to execute the unit tests via [Vitest](https://vitest.dev/).

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,320 @@
+// 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;
+  }
+  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
+    }),
+    {}
+  );
+  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/dist/lib/get-shared.d.ts

@@ -0,0 +1,20 @@
+type Type<T> = new () => T;
+export type ShareObject = {
+    version: string;
+    scope?: string;
+    get: () => Promise<() => Type<unknown>>;
+    shareConfig?: {
+        singleton?: boolean;
+        requiredVersion: string;
+    };
+};
+export type ShareConfig = {
+    [pkgName: string]: Array<ShareObject>;
+};
+export type ShareOptions = {
+    singleton: boolean;
+    requiredVersionPrefix: '^' | '~' | '>' | '>=' | '';
+};
+export declare function getShared(options?: ShareOptions): ShareConfig;
+export {};
+//# sourceMappingURL=get-shared.d.ts.map

package/dist/lib/get-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-shared.d.ts","sourceRoot":"","sources":["../../src/lib/get-shared.ts"],"names":[],"mappings":"AAAA,KAAK,IAAI,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC;AAS3B,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACxC,WAAW,CAAC,EAAE;QACZ,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,qBAAqB,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC;CACpD,CAAC;AAOF,wBAAgB,SAAS,CAAC,OAAO,eAAsB,eAyCtD"}

package/dist/lib/init-federation.d.ts

@@ -0,0 +1,105 @@
+import type { FederationInfo } from '@softarc/native-federation/domain';
+import { type InitFederationOptions, type ProcessRemoteInfoOptions } from './model/federation-info.js';
+import { type ImportMap } from './model/import-map.js';
+/**
+ * Initializes the Native Federation runtime for the host application.
+ *
+ * This is the main entry point for setting up federation. It performs the following:
+ * 1. Loads the host's remoteEntry.json to discover shared dependencies
+ * 2. Loads each remote's remoteEntry.json to discover exposed modules
+ * 3. Creates an ES Module import map with proper scoping
+ * 4. Injects the import map into the DOM as a <script type="importmap-shim">
+ *
+ * The import map allows dynamic imports to resolve correctly:
+ * - Host shared deps go in root imports (e.g., "angular": "./angular.js")
+ * - Remote exposed modules go in root imports (e.g., "mfe1/Component": "http://...")
+ * - Remote shared deps go in scoped imports for proper resolution
+ *
+ * @param remotesOrManifestUrl - Either:
+ *   - A record of remote names to their remoteEntry.json URLs
+ *     Example: { mfe1: 'http://localhost:3000/remoteEntry.json' }
+ *   - A URL to a manifest.json that contains the remotes record
+ *     Example: 'http://localhost:3000/federation-manifest.json'
+ *
+ * @param options - Configuration options:
+ *   - cacheTag: A version string to append as query param for cache busting
+ *     Example: { cacheTag: 'v1.0.0' } results in '?t=v1.0.0' on all requests
+ *
+ * @returns The final merged ImportMap that was injected into the DOM
+ *
+ */
+export declare function initFederation(remotesOrManifestUrl?: Record<string, string> | string, options?: InitFederationOptions): Promise<ImportMap>;
+/**
+ * Fetches and registers multiple remote applications in parallel and merges their import maps.
+ *
+ * This function is the orchestrator for loading all remotes. It:
+ * 1. Creates a promise for each remote to load its remoteEntry.json
+ * 2. Applies cache busting to each remote URL
+ * 3. Handles errors gracefully (logs or throws based on options)
+ * 4. Merges all successful remote import maps into one
+ *
+ * Each remote contributes:
+ * - Its exposed modules to the root imports
+ * - Its shared dependencies to scoped imports
+ *
+ * @param remotes - Record of remote names to their remoteEntry.json URLs
+ * @param options - Processing options including:
+ *   - throwIfRemoteNotFound: Whether to throw or log on remote load failure
+ *   - cacheTag: Cache busting tag to append to URLs
+ *
+ * @returns Merged import map containing all remotes' contributions
+ *
+ */
+export declare function fetchAndRegisterRemotes(remotes: Record<string, string>, options?: ProcessRemoteInfoOptions): Promise<ImportMap>;
+/**
+ * @deprecated Use `fetchAndRegisterRemotes` instead.
+ * @param remotes
+ * @param options
+ * @returns
+ */
+export declare function processRemoteInfos(remotes: Record<string, string>, options?: ProcessRemoteInfoOptions): Promise<ImportMap>;
+/**
+ * Fetches a single remote application's remoteEntry.json file and registers it in the system (global registry).
+ *
+ * This function handles everything needed to integrate one remote:
+ * 1. Fetches the remote's remoteEntry.json file
+ * 2. Extracts the base URL from the remoteEntry path
+ * 3. Creates import map entries for exposed modules and shared deps
+ * 4. Registers the remote in the global remotes registry
+ * 5. Sets up hot reload watching if configured (development mode)
+ *
+ * @param federationInfoUrl - Full URL to the remote's remoteEntry.json
+ * @param remoteName - Name to use for this remote (optional, uses info.name if not provided)
+ *
+ * @returns Import map containing this remote's exposed modules and shared dependencies
+ *
+ * @example
+ * ```typescript
+ * const importMap = await fetchAndRegisterRemote(
+ *   'http://localhost:3000/mfe1/remoteEntry.json',
+ *   'mfe1'
+ * );
+ * // Result: {
+ * //   imports: { 'mfe1/Component': 'http://localhost:3000/mfe1/Component.js' },
+ * //   scopes: { 'http://localhost:3000/mfe1/': { 'lodash': '...' } }
+ * // }
+ * ```
+ */
+export declare function fetchAndRegisterRemote(federationInfoUrl: string, remoteName?: string): Promise<ImportMap>;
+/**
+ * Processes the host application's federation info into an import map.
+ *
+ * The host app typically doesn't expose modules (it's the consumer),
+ * but it does share dependencies that should be available to remotes.
+ *
+ * Host shared dependencies go in root-level imports (not scoped) because:
+ * 1. The host loads first and establishes the base environment
+ * 2. Remotes should prefer host versions to avoid duplication
+ *
+ * @param hostInfo - Federation info from the host's remoteEntry.json
+ * @param relBundlesPath - Relative path to the host's bundle directory (default: './')
+ *
+ * @returns Import map with host's shared dependencies in root imports
+ */
+export declare function processHostInfo(hostInfo: FederationInfo, relBundlesPath?: string): Promise<ImportMap>;
+//# sourceMappingURL=init-federation.d.ts.map

package/dist/lib/init-federation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-federation.d.ts","sourceRoot":"","sources":["../../src/lib/init-federation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAExE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,KAAK,SAAS,EAA8C,MAAM,uBAAuB,CAAC;AAMnG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,cAAc,CAClC,oBAAoB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAW,EAC1D,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,SAAS,CAAC,CA4BpB;AA8CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,OAAO,GAAE,wBAA2D,GACnE,OAAO,CAAC,SAAS,CAAC,CAuBpB;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,OAAO,GAAE,wBAA2D,GACnE,OAAO,CAAC,SAAS,CAAC,CAEpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,sBAAsB,CAC1C,iBAAiB,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,SAAS,CAAC,CAqBpB;AAqID;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,cAAc,EACxB,cAAc,SAAO,GACpB,OAAO,CAAC,SAAS,CAAC,CAkBpB"}

package/dist/lib/load-remote-module.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Options for loading a remote module.
+ *
+ * @template T - The expected type of the module's exports
+ *
+ * @property remoteEntry - Optional URL to the remote's remoteEntry.json file.
+ *   Used for lazy-loading remotes that weren't registered during initFederation
+ *   Example: 'http://localhost:3000/remoteEntry.json'
+ *
+ * @property remoteName - Optional name of the remote application.
+ *   Should match the name used during initFederation or the name in remoteEntry.json.
+ *   Example: 'mfe1'
+ *
+ * @property exposedModule - The key of the exposed module to load (required).
+ *   Must match the key defined in the remote's federation config.
+ *   Example: './Component' or './Dashboard'
+ *
+ * @property fallback - Optional fallback value to return if the remote or module cannot be loaded.
+ *   Prevents throwing errors and provides graceful degradation.
+ *   Example: A default component or null
+ */
+export type LoadRemoteModuleOptions<T = any> = {
+    remoteEntry?: string;
+    remoteName?: string;
+    exposedModule: string;
+    fallback?: T;
+};
+/**
+ * Dynamically loads a remote module at runtime from a federated application.
+ *
+ * This is the primary API for consuming remote modules after federation has been initialized.
+ * It supports two calling patterns:
+ *
+ * **Pattern 1: Using options object**
+ * ```typescript
+ * const module = await loadRemoteModule({
+ *   remoteName: 'mfe1',
+ *   exposedModule: './Component',
+ *   fallback: DefaultComponent
+ * });
+ * ```
+ *
+ * **Pattern 2: Using positional arguments**
+ * ```typescript
+ * const module = await loadRemoteModule('mfe1', './Component');
+ * ```
+ *
+ * ## Loading Process
+ *
+ * 1. **Normalize Options**: Converts arguments into a standard options object
+ * 2. **Ensure Remote Initialized**: If remoteEntry is provided and remote isn't loaded,
+ *    fetches and registers it dynamically
+ * 3. **Resolve Remote Name**: Determines remote name from options or remoteEntry URL
+ * 4. **Validate Remote**: Checks if remote exists in the registry
+ * 5. **Validate Exposed Module**: Verifies the requested module is exposed by the remote
+ * 6. **Import Module**: Uses dynamic import or import-shim to load the module
+ * 7. **Handle Errors**: Returns fallback if provided, otherwise throws
+ *
+ * ## Lazy Loading Support
+ *
+ * If you provide a `remoteEntry` URL for a remote that wasn't initialized during
+ * `initFederation()`, this function will automatically:
+ * - Fetch the remote's remoteEntry.json
+ * - Register it in the global registry
+ * - Update the import map
+ * - Then load the requested module
+ *
+ * This enables on-demand loading of remotes based on user interactions.
+ *
+ *
+ * @template T - The expected type of the module's exports
+ *
+ * @param options - Configuration object for loading the remote module
+ * @returns Promise resolving to the loaded module or fallback value
+ *
+ * @throws Error if remote is not found and no fallback is provided
+ * @throws Error if exposed module doesn't exist and no fallback is provided
+ * @throws Error if module import fails and no fallback is provided
+ *
+ */
+export declare function loadRemoteModule<T = any>(options: LoadRemoteModuleOptions): Promise<T>;
+export declare function loadRemoteModule<T = any>(remoteName: string, exposedModule: string): Promise<T>;
+//# sourceMappingURL=load-remote-module.d.ts.map

package/dist/lib/load-remote-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-remote-module.d.ts","sourceRoot":"","sources":["../../src/lib/load-remote-module.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,GAAG,GAAG,IAAI;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,CAAC,CAAC;CACd,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAC9F,wBAAsB,gBAAgB,CAAC,CAAC,GAAG,GAAG,EAC5C,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,CAAC,CAAC,CAAC"}

package/dist/lib/model/build-notifications-options.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILD_NOTIFICATIONS_ENDPOINT = "/@angular-architects/native-federation:build-notifications";
+//# sourceMappingURL=build-notifications-options.d.ts.map

package/dist/lib/model/build-notifications-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-notifications-options.d.ts","sourceRoot":"","sources":["../../../src/lib/model/build-notifications-options.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,+DACqB,CAAC"}

package/dist/lib/model/externals.d.ts

@@ -0,0 +1,4 @@
+import type { SharedInfo } from '@softarc/native-federation/domain';
+export declare function getExternalUrl(shared: SharedInfo): string | undefined;
+export declare function setExternalUrl(shared: SharedInfo, url: string): void;
+//# sourceMappingURL=externals.d.ts.map

package/dist/lib/model/externals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"externals.d.ts","sourceRoot":"","sources":["../../../src/lib/model/externals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AASpE,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAGrE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAGpE"}

package/dist/lib/model/federation-info.d.ts

@@ -0,0 +1,7 @@
+export interface InitFederationOptions {
+    cacheTag?: string;
+}
+export interface ProcessRemoteInfoOptions extends InitFederationOptions {
+    throwIfRemoteNotFound: boolean;
+}
+//# sourceMappingURL=federation-info.d.ts.map

package/dist/lib/model/federation-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-info.d.ts","sourceRoot":"","sources":["../../../src/lib/model/federation-info.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,wBAAyB,SAAQ,qBAAqB;IACrE,qBAAqB,EAAE,OAAO,CAAC;CAChC"}

package/dist/lib/model/global-cache.d.ts

@@ -0,0 +1,12 @@
+import type { Remote } from './remotes.js';
+export declare const nfNamespace = "__NATIVE_FEDERATION__";
+export type NfCache = {
+    externals: Map<string, string>;
+    remoteNamesToRemote: Map<string, Remote>;
+    baseUrlToRemoteNames: Map<string, string>;
+};
+export type Global = {
+    [nfNamespace]: NfCache;
+};
+export declare const globalCache: NfCache;
+//# sourceMappingURL=global-cache.d.ts.map

package/dist/lib/model/global-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-cache.d.ts","sourceRoot":"","sources":["../../../src/lib/model/global-cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,eAAO,MAAM,WAAW,0BAA0B,CAAC;AAEnD,MAAM,MAAM,OAAO,GAAG;IACpB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IACnB,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAUF,eAAO,MAAM,WAAW,SAAsB,CAAC"}

package/dist/lib/model/import-map.d.ts

@@ -0,0 +1,8 @@
+export type Imports = Record<string, string>;
+export type Scopes = Record<string, Imports>;
+export type ImportMap = {
+    imports: Imports;
+    scopes: Scopes;
+};
+export declare function mergeImportMaps(map1: ImportMap, map2: ImportMap): ImportMap;
+//# sourceMappingURL=import-map.d.ts.map

package/dist/lib/model/import-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-map.d.ts","sourceRoot":"","sources":["../../../src/lib/model/import-map.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE7C,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAK3E"}

package/dist/lib/model/remotes.d.ts

@@ -0,0 +1,10 @@
+import type { FederationInfo } from '@softarc/native-federation/domain';
+export type Remote = FederationInfo & {
+    baseUrl: string;
+};
+export declare function addRemote(remoteName: string, remote: Remote): void;
+export declare function getRemoteNameByBaseUrl(baseUrl: string): string | undefined;
+export declare function isRemoteInitialized(baseUrl: string): boolean;
+export declare function getRemote(remoteName: string): Remote | undefined;
+export declare function hasRemote(remoteName: string): boolean;
+//# sourceMappingURL=remotes.d.ts.map

package/dist/lib/model/remotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remotes.d.ts","sourceRoot":"","sources":["../../../src/lib/model/remotes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGxE,MAAM,MAAM,MAAM,GAAG,cAAc,GAAG;IACpC,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAKF,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAGlE;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEhE;AAED,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAErD"}

package/dist/lib/utils/add-import-map.d.ts

@@ -0,0 +1,3 @@
+import type { ImportMap } from '../model/import-map.js';
+export declare function appendImportMap(importMap: ImportMap): void;
+//# sourceMappingURL=add-import-map.d.ts.map

package/dist/lib/utils/add-import-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-import-map.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/add-import-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,QAOnD"}

package/dist/lib/utils/path-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the full directory of a given path.
+ * @param url - The path to get the directory of.
+ * @returns The full directory of the path.
+ */
+export declare function getDirectory(url: string): string;
+/**
+ * Joins two paths together taking into account trailing slashes and "./" prefixes.
+ * @param path1 - The first path to join.
+ * @param path2 - The second path to join.
+ * @returns The joined path.
+ */
+export declare function joinPaths(path1: string, path2: string): string;
+//# sourceMappingURL=path-utils.d.ts.map