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

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

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/path-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,UAIvC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UASrD"}

package/dist/lib/utils/trusted-types.d.ts

@@ -0,0 +1,2 @@
+export declare function tryCreateTrustedScript(script: string): string | TrustedScript;
+//# sourceMappingURL=trusted-types.d.ts.map

package/dist/lib/utils/trusted-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted-types.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/trusted-types.ts"],"names":[],"mappings":"AA2BA,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa,CAE7E"}

package/dist/lib/watch-federation-build.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ */
+export declare function watchFederationBuildCompletion(endpoint: string): void;
+//# sourceMappingURL=watch-federation-build.d.ts.map

package/dist/lib/watch-federation-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-federation-build.d.ts","sourceRoot":"","sources":["../../src/lib/watch-federation-build.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,QAc9D"}

package/package.json

@@ -1,24 +1,43 @@
 {
   "name": "@softarc/native-federation-runtime",
-  "version": "3.5.0",
+  "version": "4.0.0-RC1",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
   "dependencies": {
-    "tslib": "^2.3.0"
+    "@softarc/native-federation": "4.0.0-RC1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "vitest": "^3.0.0",
+    "@vitest/ui": "^3.0.0",
+    "@types/trusted-types": "^2.0.7"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run --project=unit",
+    "test:integration": "vitest run --project=integration"
   },
   "msw": {
     "workerDirectory": [
       "public"
     ]
-  },
-  "module": "fesm2022/softarc-native-federation-runtime.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/softarc-native-federation-runtime.mjs"
-    }
-  },
-  "sideEffects": false
-}
+  }
+}

package/LICENSE

@@ -1,8 +0,0 @@
-Copyright 2021 Softarc Consulting GmbH
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-

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

@@ -1,568 +0,0 @@
-const nfNamespace = '__NATIVE_FEDERATION__';
-const global = globalThis;
-global[nfNamespace] ??= {
-    externals: new Map(),
-    remoteNamesToRemote: new Map(),
-    baseUrlToRemoteNames: new Map(),
-};
-const globalCache = global[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);
-}
-
-function appendImportMap(importMap) {
-    document.head.appendChild(Object.assign(document.createElement('script'), {
-        type: 'importmap-shim',
-        innerHTML: 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 fetchAndRegisterRemotes(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 fetchAndRegisterRemotes(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, fetchAndRegisterRemotes, initFederation, loadRemoteModule, mergeImportMaps, processHostInfo };
-//# sourceMappingURL=softarc-native-federation-runtime.mjs.map