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

package/fesm2022/softarc-native-federation-runtime.mjs

@@ -1,631 +0,0 @@
-const defaultShareOptions = {
-    singleton: false,
-    requiredVersionPrefix: '',
-};
-function getShared(options = defaultShareOptions) {
-    const nfc = window;
-    const externals = nfc.__NATIVE_FEDERATION__.externals;
-    const shared = {};
-    const allKeys = [...externals.keys()];
-    const keys = allKeys
-        .filter((k) => !k.startsWith('/@id/') &&
-        !k.startsWith('@angular-architects/module-federation') &&
-        !k.endsWith('@'))
-        .sort();
-    for (const key of keys) {
-        const idx = key.lastIndexOf('@');
-        const pkgName = key.substring(0, idx);
-        const version = key.substring(idx + 1);
-        const path = externals.get(key) ?? '';
-        const shareObj = {
-            version,
-            get: async () => {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const lib = await window.importShim(path);
-                return () => lib;
-            },
-            shareConfig: {
-                singleton: options.singleton,
-                requiredVersion: options.requiredVersionPrefix + version,
-            },
-        };
-        if (!shared[pkgName]) {
-            shared[pkgName] = [];
-        }
-        shared[pkgName].push(shareObj);
-    }
-    return shared;
-}
-
-const nfNamespace = '__NATIVE_FEDERATION__';
-const global$1 = globalThis;
-global$1[nfNamespace] ??= {
-    externals: new Map(),
-    remoteNamesToRemote: new Map(),
-    baseUrlToRemoteNames: new Map(),
-};
-const globalCache = global$1[nfNamespace];
-
-const 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);
-}
-
-function mergeImportMaps(map1, map2) {
-    return {
-        imports: { ...map1.imports, ...map2.imports },
-        scopes: { ...map1.scopes, ...map2.scopes },
-    };
-}
-
-const remoteNamesToRemote = globalCache.remoteNamesToRemote;
-const 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);
-}
-function hasRemote(remoteName) {
-    return remoteNamesToRemote.has(remoteName);
-}
-
-const global = globalThis;
-let policy;
-function createPolicy() {
-    if (policy === undefined) {
-        policy = null;
-        if (global.trustedTypes) {
-            try {
-                policy = global.trustedTypes.createPolicy('native-federation', {
-                    createHTML: (html) => html,
-                    createScript: (script) => script,
-                    createScriptURL: (url) => url,
-                });
-            }
-            catch {
-                // trustedTypes.createPolicy may throw an exception if called with a name that is already registered, even in report-only mode.
-            }
-        }
-    }
-    return policy;
-}
-function tryCreateTrustedScript(script) {
-    return createPolicy()?.createScript(script) ?? script;
-}
-
-function appendImportMap(importMap) {
-    document.head.appendChild(Object.assign(document.createElement('script'), {
-        type: tryCreateTrustedScript('importmap-shim'),
-        textContent: tryCreateTrustedScript(JSON.stringify(importMap)),
-    }));
-}
-
-/**
- * Returns the full directory of a given path.
- * @param url - The path to get the directory of.
- * @returns The full directory of the path.
- */
-function getDirectory(url) {
-    const parts = url.split('/');
-    parts.pop();
-    return parts.join('/');
-}
-/**
- * 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.
- */
-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}`;
-}
-
-const BUILD_NOTIFICATIONS_ENDPOINT = '/@angular-architects/native-federation:build-notifications';
-var BuildNotificationType;
-(function (BuildNotificationType) {
-    BuildNotificationType["COMPLETED"] = "federation-rebuild-complete";
-    BuildNotificationType["ERROR"] = "federation-rebuild-error";
-    BuildNotificationType["CANCELLED"] = "federation-rebuild-cancelled";
-})(BuildNotificationType || (BuildNotificationType = {}));
-
-/**
- * Watches for federation build completion events and automatically reloads the page.
- *
- * This function establishes a Server-Sent Events (SSE) connection to listen for
- * 'federation-rebuild-complete' notifications. When a build completes successfully,
- * it triggers a page reload to reflect the latest changes.
- * @param endpoint - The SSE endpoint URL to watch for build notifications.
- */
-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);
-    };
-}
-
-/**
- * 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
- *
- */
-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);
-    // Host application is fully loaded, now we can process the remotes
-    // Each remote contributes:
-    // - Exposed modules to root imports
-    // - Shared dependencies to scoped imports
-    const remotesImportMap = await processRemoteInfos(normalizedRemotes, {
-        throwIfRemoteNotFound: false,
-        ...options,
-    });
-    const mergedImportMap = mergeImportMaps(hostImportMap, remotesImportMap);
-    // Inject the final import map into the DOM with importmap-shim
-    appendImportMap(mergedImportMap);
-    return mergedImportMap;
-}
-/**
- * Loads a federation manifest file (JSON) from the given URL.
- *
- * The manifest should map remote names to their remoteEntry.json URLs.
- *
- * @param manifestUrl - The URL to the manifest.json file.
- * @returns A promise resolving to an object mapping remote names to their remoteEntry.json URLs.
- */
-async function loadManifest(manifestUrl) {
-    const manifest = (await fetch(manifestUrl).then((r) => r.json()));
-    return manifest;
-}
-/**
- * Adds cache busting query parameter to a URL if cacheTag is provided.
- */
-function applyCacheTag(url, cacheTag) {
-    if (!cacheTag)
-        return url;
-    const separator = url.includes('?') ? '&' : '?';
-    return `${url}${separator}t=${cacheTag}`;
-}
-/**
- * Handles errors when loading a remote entry.
- * Either throws or logs based on options.
- */
-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;
-}
-/**
- * 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
- *
- */
-async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) {
-    // Each promise will independently fetch and process its remoteEntry.json
-    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);
-    // Filter out failed remotes (null values) and merge successful ones
-    const importMap = remoteImportMaps.reduce((acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc, { imports: {}, scopes: {} });
-    return 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': '...' } }
- * // }
- * ```
- */
-async function fetchAndRegisterRemote(federationInfoUrl, remoteName) {
-    const baseUrl = getDirectory(federationInfoUrl);
-    const remoteInfo = await loadFederationInfo(federationInfoUrl);
-    // Uses the name from the remote's remoteEntry.json if not explicitly provided
-    if (!remoteName) {
-        remoteName = remoteInfo.name;
-    }
-    // Setup hot reload watching for development mode and in case it has a build notifications endpoint
-    if (remoteInfo.buildNotificationsEndpoint) {
-        watchFederationBuildCompletion(baseUrl + remoteInfo.buildNotificationsEndpoint);
-    }
-    const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl);
-    // Register this remote in the global registry
-    addRemote(remoteName, { ...remoteInfo, baseUrl });
-    return importMap;
-}
-/**
- * Creates an import map for a remote application.
- *
- * The import map has two parts:
- * 1. Imports (root level): Maps remote's exposed modules
- *    Example: "mfe1/Component" -> "http://localhost:3000/mfe1/Component.js"
- *
- * 2. Scopes: Maps remote's shared dependencies within its scope
- *    Example: "http://localhost:3000/mfe1/": { "lodash": "http://localhost:3000/mfe1/lodash.js" }
- *
- * Scoping ensures that when a module from this remote imports 'lodash',
- * it gets the version from this remote's bundle, not another version.
- *
- * @param remoteInfo - Federation info from the remote's remoteEntry.json
- * @param remoteName - Name used to prefix exposed module keys
- * @param baseUrl - Base URL where the remote is hosted
- *
- * @returns Import map with imports and scopes for this remote
- */
-function createRemoteImportMap(remoteInfo, remoteName, baseUrl) {
-    const imports = processExposed(remoteInfo, remoteName, baseUrl);
-    const scopes = processRemoteImports(remoteInfo, baseUrl);
-    return { imports, scopes };
-}
-/**
- * Fetches and parses a remoteEntry.json file.
- *
- * The remoteEntry.json contains metadata about a federated module:
- * - name: The application name
- * - exposes: Array of modules this app exposes to others
- * - shared: Array of dependencies this app shares
- * - buildNotificationsEndpoint: Optional SSE endpoint for hot reload (development mode)
- *
- * @param remoteEntryUrl - URL to the remoteEntry.json file (can be relative or absolute)
- * @returns Parsed federation info object
- */
-async function loadFederationInfo(remoteEntryUrl) {
-    const info = (await fetch(remoteEntryUrl).then((r) => r.json()));
-    return info;
-}
-/**
- * Processes a remote's shared dependencies into scoped import map entries.
- *
- * Shared dependencies need to be scoped to avoid version conflicts.
- * When a module from "http://localhost:3000/mfe1/" imports "lodash",
- * the import map scope ensures it gets the correct version.
- *
- * Scope structure:
- * {
- *   "http://localhost:3000/mfe1/": {
- *     "lodash": "http://localhost:3000/mfe1/lodash.js",
- *     "rxjs": "http://localhost:3000/mfe1/rxjs.js"
- *   }
- * }
- *
- * This function also manages external URLs - if a shared dependency
- * has already been loaded from another location, it can reuse that URL.
- *
- * @param remoteInfo - Federation info containing shared dependencies
- * @param baseUrl - Base URL of the remote (used as the scope key)
- *
- * @returns Scopes object mapping baseUrl to its shared dependencies
- */
-function processRemoteImports(remoteInfo, baseUrl) {
-    const scopes = {};
-    const scopedImports = {};
-    for (const shared of remoteInfo.shared) {
-        // Check if this dependency already has an external URL registered
-        // If not, construct the URL from the base path and output filename
-        const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName);
-        // Register this URL as the external location for this shared dependency
-        // This allows other remotes to potentially reuse this version
-        setExternalUrl(shared, outFileName);
-        // Add to the scoped imports: package name -> full URL
-        scopedImports[shared.packageName] = outFileName;
-    }
-    scopes[baseUrl + '/'] = scopedImports;
-    return scopes;
-}
-/**
- * Processes a remote's exposed modules into root-level import map entries.
- *
- * Exposed modules are what the remote makes available to other applications.
- * They go in the root imports (not scoped) so any app can import them.
- *
- * Example exposed module:
- * - Remote 'mfe1' exposes './Component' from file 'Component.js'
- * - Results in: "mfe1/Component" -> "http://localhost:3000/mfe1/Component.js"
- *
- * This allows other apps to do:
- * ```typescript
- * import { Component } from 'mfe1/Component';
- * ```
- *
- * @param remoteInfo - Federation info containing exposed modules
- * @param remoteName - Name to prefix the exposed keys with
- * @param baseUrl - Base URL where the remote's files are hosted
- *
- * @returns Imports object mapping remote module keys to their URLs
- */
-function processExposed(remoteInfo, remoteName, baseUrl) {
-    const imports = {};
-    for (const exposed of remoteInfo.exposes) {
-        // Create the import key by joining remote name with the exposed key
-        // Example: 'mfe1' + './Component' -> 'mfe1/Component'
-        const key = joinPaths(remoteName, exposed.key);
-        // Create the full URL to the exposed module's output file
-        // Example: 'http://localhost:3000/mfe1' + 'Component.js' -> 'http://localhost:3000/mfe1/Component.js'
-        const value = joinPaths(baseUrl, exposed.outFileName);
-        imports[key] = value;
-    }
-    return imports;
-}
-/**
- * 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
- */
-async function processHostInfo(hostInfo, relBundlesPath = './') {
-    // Transform shared array into imports object
-    const imports = hostInfo.shared.reduce((acc, cur) => ({
-        ...acc,
-        [cur.packageName]: relBundlesPath + cur.outFileName,
-    }), {});
-    // Register external URLs for host's shared dependencies
-    // This allows remotes to discover and potentially reuse these versions
-    for (const shared of hostInfo.shared) {
-        setExternalUrl(shared, relBundlesPath + shared.outFileName);
-    }
-    // Host doesn't have scopes - its shared deps are at root level
-    return { imports, scopes: {} };
-}
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-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;
-    // Handles errors when the remote is missing
-    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);
-    // Handles errors when the exposed module is missing
-    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) {
-        // Handles errors when the module import fails
-        if (fallback) {
-            console.error('error loading remote module', e);
-            return fallback;
-        }
-        throw e;
-    }
-}
-/**
- * Internal helper function to perform the dynamic import.
- *
- * @template T - The expected type of the module's exports
- * @param moduleUrl - Full URL to the module file to import
- * @returns Promise resolving to the imported module
- */
-function _import(moduleUrl) {
-    return typeof importShim !== 'undefined'
-        ? importShim(moduleUrl)
-        : import(/* @vite-ignore */ moduleUrl);
-}
-/**
- * Resolves the remote name from the provided options.
- *
- * The remote name can be determined in two ways:
- * 1. If options.remoteName is provided, use it directly
- * 2. If only remoteEntry is provided, extract the baseUrl
- *    and look up the remote name from the registry using that baseUrl
- *
- * @param options - Load options containing remoteName and/or remoteEntry
- * @returns The resolved remote name
- *
- * @throws Error if neither remoteName nor remoteEntry is provided
- * @throws Error if the remote name cannot be determined
- */
-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;
-}
-/**
- * Ensures that the remote is initialized before attempting to load a module from it.
- *
- * This function enables lazy-loading of remotes that weren't registered during
- * the initial `initFederation()` call. It checks if:
- * 1. A remoteEntry URL is provided in the options
- * 2. The remote at that URL hasn't been initialized yet
- *
- * If both conditions are true, it:
- * 1. Fetches the remote's remoteEntry.json file
- * 2. Registers the remote in the global registry
- * 3. Creates and appends the remote's import map to the DOM
- *
- * @param options - Load options containing optional remoteEntry URL
- * @returns Promise that resolves when the remote is initialized (or immediately if already initialized)
- *
- */
-async function ensureRemoteInitialized(options) {
-    if (options.remoteEntry &&
-        !isRemoteInitialized(getDirectory(options.remoteEntry))) {
-        const importMap = await fetchAndRegisterRemote(options.remoteEntry);
-        appendImportMap(importMap);
-    }
-}
-/**
- * Normalizes the function arguments into a standard LoadRemoteModuleOptions object.
- *
- * The function detects which pattern is being used and converts it to the
- * standard options object format for consistent internal processing.
- *
- * @param optionsOrRemoteName - Either an options object or the remote name string
- * @param exposedModule - The exposed module key
- * @returns Normalized options object
- *
- * @throws Error if arguments don't match either supported pattern
- */
-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;
-}
-/**
- * Logs an error message to the console, but only in browser environments.
- *
- * @param error - The error message to log
- *
- */
-function logClientError(error) {
-    if (typeof window !== 'undefined') {
-        console.error(error);
-    }
-}
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { BUILD_NOTIFICATIONS_ENDPOINT, BuildNotificationType, fetchAndRegisterRemote, getShared, initFederation, loadRemoteModule, mergeImportMaps, processHostInfo, processRemoteInfos };
-//# sourceMappingURL=softarc-native-federation-runtime.mjs.map