From 8cdcbc99497798b934e8bc9665be108912bc16bb Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Sat, 6 Dec 2025 09:45:14 +0100 Subject: [PATCH 01/16] fix: Enhanced package.json export support --- .../src/lib/utils/package-info.ts | 231 ++++++++---------- 1 file changed, 108 insertions(+), 123 deletions(-) diff --git a/libs/native-federation-core/src/lib/utils/package-info.ts b/libs/native-federation-core/src/lib/utils/package-info.ts index 91d48fba..c521ba3d 100644 --- a/libs/native-federation-core/src/lib/utils/package-info.ts +++ b/libs/native-federation-core/src/lib/utils/package-info.ts @@ -22,6 +22,34 @@ export type PackageJsonInfo = { directory: string; }; +export type ExportCondition = + | 'import' + | 'require' + | 'node' + | 'cjs' + | 'esm' + | 'default' + | 'types' + | 'browser' + | (string & {}); + +export const isESMExport = (e: string): boolean | undefined => { + if (e === 'node' || e === 'import' || e.startsWith('es')) return true; + if (e === 'require' || e === 'cjs') return false; + return undefined; +}; + +export type ExportEntry = + | string + | undefined + | { [key in ExportCondition]?: ExportEntry } + | ExportEntry[]; + +export type PackageJsonExports = + | string + | ExportEntry + | { [path: `.${string}`]: ExportEntry }; + const packageCache: Record = {}; export function findPackageJsonFiles( @@ -151,6 +179,55 @@ export function findDepPackageJson( return mainPkgJsonPath; } +function replaceGlob(target: ExportEntry, replacement: string): ExportEntry { + if (!target) return undefined; + if (typeof target === 'string') return target.replace('*', replacement); + return Object.entries(target).reduce( + (a, [k, v]) => ({ + ...a, + [k]: replaceGlob(v!, replacement), + }), + {} as Omit, + ); +} + +function findOptimalExport( + target: ExportEntry, + info: PackageInfo, + isESM: boolean | undefined = undefined, +): PackageInfo | undefined { + if (typeof target === 'string') { + return { + ...info, + entryPoint: path.join(info.entryPoint, target), + esm: isESM ?? info.esm, + }; + } + if (!target) return undefined; + if (Array.isArray(target)) return findOptimalExport(target[0], info, isESM); + + const exportTypes = Object.keys(target); + + if (typeof isESM === 'undefined') { + const esmExport = exportTypes.find((e) => isESMExport(e)); + if (esmExport) { + return findOptimalExport(target[esmExport], info, true); + } + } + + const secondBestEntry = + 'default' in target && target['default'] + ? 'default' + : exportTypes.filter((e) => e !== 'types')[0]; + const secondBestExport: ExportEntry = target[secondBestEntry]; + + return findOptimalExport( + secondBestExport, + info, + isESM ?? isESMExport(secondBestEntry), + ); +} + export function _getPackageInfo( packageName: string, directory: string, @@ -181,121 +258,46 @@ export function _getPackageInfo( ? '.' : './' + pathToSecondary.replace(/\\/g, '/'); - let secondaryEntryPoint = mainPkgJson?.exports?.[relSecondaryPath]; - - // wildcard - if (!secondaryEntryPoint) { - const wildcardEntry = Object.keys(mainPkgJson?.exports ?? []).find((e) => - e.startsWith('./*'), - ); - if (wildcardEntry) { - secondaryEntryPoint = mainPkgJson?.exports?.[wildcardEntry]; - if (typeof secondaryEntryPoint === 'string') - secondaryEntryPoint = secondaryEntryPoint.replace('*', pathToSecondary); - if (typeof secondaryEntryPoint === 'object') - Object.keys(secondaryEntryPoint).forEach(function (key) { - secondaryEntryPoint[key] = secondaryEntryPoint[key].replace( - '*', - pathToSecondary, - ); - }); - } - } - - if (typeof secondaryEntryPoint === 'string') { - return { - entryPoint: path.join(mainPkgPath, secondaryEntryPoint), - packageName, - version, - esm, - }; - } - - let cand = secondaryEntryPoint?.import; - - if (typeof cand === 'object') { - if (cand.module) { - cand = cand.module; - } else if (cand.import) { - cand = cand.import; - } else if (cand.default) { - cand = cand.default; - } else { - cand = null; - } - } - - if (cand) { - if (typeof cand === 'object') { - if (cand.module) { - cand = cand.module; - } else if (cand.import) { - cand = cand.import; - } else if (cand.default) { - cand = cand.default; - } else { - cand = null; - } - } - - return { - entryPoint: path.join(mainPkgPath, cand), - packageName, - version, - esm, - }; - } + let secondaryEntryPoint: ExportEntry = undefined; + + // Node.js looks at the exports object and uses the first key that matches the current environment. + const packageJsonExportsEntry = Object.keys(mainPkgJson?.exports ?? []).find( + (e) => { + if (e === relSecondaryPath) return true; + if (e === './*') return true; + if (!e.endsWith('*')) return false; + const globPath = e.substring(0, e.length - 1); + return relSecondaryPath.startsWith(globPath); + }, + ); - cand = secondaryEntryPoint?.module; - - if (typeof cand === 'object') { - if (cand.module) { - cand = cand.module; - } else if (cand.import) { - cand = cand.import; - } else if (cand.default) { - cand = cand.default; - } else { - cand = null; + if (packageJsonExportsEntry) { + secondaryEntryPoint = packageJsonExportsEntry; + + if (secondaryEntryPoint.endsWith('*')) { + const replacement = relSecondaryPath.substring( + packageJsonExportsEntry.length - 1, + ); + secondaryEntryPoint = replaceGlob( + mainPkgJson?.exports?.[packageJsonExportsEntry], + replacement, + ); } } - if (cand) { - return { - entryPoint: path.join(mainPkgPath, cand), - packageName, - version, - esm, - }; - } - - cand = secondaryEntryPoint?.default; - if (cand) { - if (typeof cand === 'object') { - if (cand.module) { - cand = cand.module; - } else if (cand.import) { - cand = cand.import; - } else if (cand.default) { - cand = cand.default; - } else { - cand = null; - } - } - - return { - entryPoint: path.join(mainPkgPath, cand), + if (!!secondaryEntryPoint) { + const info = findOptimalExport(secondaryEntryPoint, { + entryPoint: mainPkgPath, packageName, version, esm, - }; + }); + if (!!info) return info; } - cand = mainPkgJson['module']; - - if (cand && relSecondaryPath === '.') { + if (mainPkgJson['module'] && relSecondaryPath === '.') { return { - entryPoint: path.join(mainPkgPath, cand), + entryPoint: path.join(mainPkgPath, mainPkgJson['module']), packageName, version, esm: true, @@ -318,7 +320,7 @@ export function _getPackageInfo( }; } - cand = path.join(secondaryPgkPath, 'index.mjs'); + let cand = path.join(secondaryPgkPath, 'index.mjs'); if (fs.existsSync(cand)) { return { entryPoint: cand, @@ -367,17 +369,6 @@ export function _getPackageInfo( }; } - // cand = secondaryPgkPath; - // if (fs.existsSync(cand) && cand.match(/\.(m|c)?js$/)) { - // return { - // entryPoint: cand, - // packageName, - // version, - // esm, - // }; - // } - - // TODO: Add logger logger.warn('No entry point found for ' + packageName); logger.warn( "If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json", @@ -401,9 +392,3 @@ function getPkgFolder(packageName: string) { return folder; } - -// const pkg = process.argv[2] -// console.log('pkg', pkg); - -// const r = getPackageInfo('D:/Dokumente/projekte/mf-plugin/angular-architects/', pkg); -// console.log('entry', r); From 926d985344b24ba01e3bd9c8d4c21ea39bb81c61 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Sat, 6 Dec 2025 13:08:08 +0100 Subject: [PATCH 02/16] fix: Exhaustive search for packages --- .../src/lib/config/share-utils.ts | 11 ++++++++++- .../src/lib/core/default-skip-list.ts | 1 - .../src/lib/utils/package-info.ts | 6 ++---- .../src/lib/utils/resolve-wildcard-keys.ts | 4 ++-- 4 files changed, 14 insertions(+), 8 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index c1538de0..1412e1bd 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -29,7 +29,9 @@ export const DEFAULT_SECONDARIES_SKIP_LIST = [ '@angular/common/upgrade', ]; -type IncludeSecondariesOptions = { skip: string | string[] } | boolean; +type IncludeSecondariesOptions = + | { skip: string | string[]; exhaustive?: boolean } + | boolean; type CustomSharedConfig = SharedConfig & { includeSecondaries?: IncludeSecondariesOptions; }; @@ -159,12 +161,14 @@ function getSecondaries( ): Record | null { let exclude = [...DEFAULT_SECONDARIES_SKIP_LIST]; + let resolveExhaustive = true; if (typeof includeSecondaries === 'object') { if (Array.isArray(includeSecondaries.skip)) { exclude = includeSecondaries.skip; } else if (typeof includeSecondaries.skip === 'string') { exclude = [includeSecondaries.skip]; } + if (includeSecondaries.exhaustive === false) resolveExhaustive = false; } // const libPath = path.join(path.dirname(packagePath), 'node_modules', key); @@ -179,6 +183,7 @@ function getSecondaries( exclude, shareObject, preparedSkipList, + resolveExhaustive, ); if (configured) { return configured; @@ -200,6 +205,7 @@ function readConfiguredSecondaries( exclude: string[], shareObject: SharedConfig, preparedSkipList: PreparedSkipList, + resolveExhaustive: boolean, ): Record | null { const libPackageJson = path.join(libPath, 'package.json'); @@ -267,6 +273,7 @@ function readConfiguredSecondaries( secondaryName, entry, { discovered: discoveredFiles, skip: exclude }, + resolveExhaustive, ); items.forEach((e) => discoveredFiles.add(typeof e === 'string' ? e : e.value), @@ -300,9 +307,11 @@ function resolveSecondaries( secondaryName: string, entry: string, excludes: { discovered: Set; skip: string[] }, + resolveExhaustive: boolean, ): Array { let items: Array = []; if (key.includes('*')) { + if (!resolveExhaustive) return items; const expanded = resolveWildcardKeys(key, entry, libPath); items = expanded .map((e) => ({ diff --git a/libs/native-federation-core/src/lib/core/default-skip-list.ts b/libs/native-federation-core/src/lib/core/default-skip-list.ts index 9b5f2977..f19ad0c4 100644 --- a/libs/native-federation-core/src/lib/core/default-skip-list.ts +++ b/libs/native-federation-core/src/lib/core/default-skip-list.ts @@ -16,7 +16,6 @@ export const DEFAULT_SKIP_LIST: SkipList = [ '@angular/localize', '@angular/localize/init', '@angular/localize/tools', - (pkg) => pkg.startsWith('rxjs/internal'), // '@angular/platform-server', // '@angular/platform-server/init', // '@angular/ssr', diff --git a/libs/native-federation-core/src/lib/utils/package-info.ts b/libs/native-federation-core/src/lib/utils/package-info.ts index c521ba3d..0c58bc56 100644 --- a/libs/native-federation-core/src/lib/utils/package-info.ts +++ b/libs/native-federation-core/src/lib/utils/package-info.ts @@ -208,6 +208,7 @@ function findOptimalExport( const exportTypes = Object.keys(target); + // We prefer ESM exports for native support. if (typeof isESM === 'undefined') { const esmExport = exportTypes.find((e) => isESMExport(e)); if (esmExport) { @@ -215,6 +216,7 @@ function findOptimalExport( } } + // Node.js looks at the exports object and uses the first key that matches the current environment. const secondBestEntry = 'default' in target && target['default'] ? 'default' @@ -246,10 +248,7 @@ export function _getPackageInfo( const esm = mainPkgJson['type'] === 'module'; if (!version) { - // TODO: Add logger - // context.logger.warn('No version found for ' + packageName); logger.warn('No version found for ' + packageName); - return null; } @@ -260,7 +259,6 @@ export function _getPackageInfo( let secondaryEntryPoint: ExportEntry = undefined; - // Node.js looks at the exports object and uses the first key that matches the current environment. const packageJsonExportsEntry = Object.keys(mainPkgJson?.exports ?? []).find( (e) => { if (e === relSecondaryPath) return true; diff --git a/libs/native-federation-core/src/lib/utils/resolve-wildcard-keys.ts b/libs/native-federation-core/src/lib/utils/resolve-wildcard-keys.ts index f96cbab8..cbe46f7e 100644 --- a/libs/native-federation-core/src/lib/utils/resolve-wildcard-keys.ts +++ b/libs/native-federation-core/src/lib/utils/resolve-wildcard-keys.ts @@ -10,10 +10,10 @@ function escapeRegex(str: string) { } // Convert package.json exports pattern to glob pattern -// * in exports means "one segment", but for glob we need ** for deep matching +// * in exports means "one segment", but for glob we need **/* for deep matching // Src: https://hirok.io/posts/package-json-exports#exposing-all-package-files function convertExportsToGlob(pattern: string) { - return pattern.replace(/(? Date: Sat, 6 Dec 2025 16:06:29 +0100 Subject: [PATCH 03/16] fix: Correct federation export and added cache breaker when switching from dev to prod --- libs/native-federation-core/src/lib/core/bundle-caching.ts | 6 +++++- libs/native-federation-core/src/lib/core/bundle-shared.ts | 2 +- .../src/lib/core/load-federation-config.ts | 3 ++- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/libs/native-federation-core/src/lib/core/bundle-caching.ts b/libs/native-federation-core/src/lib/core/bundle-caching.ts index f063567f..7c94b8ff 100644 --- a/libs/native-federation-core/src/lib/core/bundle-caching.ts +++ b/libs/native-federation-core/src/lib/core/bundle-caching.ts @@ -14,6 +14,7 @@ export const getFilename = (title: string) => { export const getChecksum = ( shared: Record, + dev: '1' | '0', ): string => { const denseExternals = Object.keys(shared) .sort() @@ -26,7 +27,10 @@ export const getChecksum = ( ); }, 'deps'); - return crypto.createHash('sha256').update(denseExternals).digest('hex'); + return crypto + .createHash('sha256') + .update(denseExternals + `:dev=${dev}`) + .digest('hex'); }; export const cacheEntry = (pathToCache: string, fileName: string) => ({ diff --git a/libs/native-federation-core/src/lib/core/bundle-shared.ts b/libs/native-federation-core/src/lib/core/bundle-shared.ts index 19670df4..d1eacf02 100644 --- a/libs/native-federation-core/src/lib/core/bundle-shared.ts +++ b/libs/native-federation-core/src/lib/core/bundle-shared.ts @@ -27,7 +27,7 @@ export async function bundleShared( platform: 'browser' | 'node' = 'browser', cacheOptions: { pathToCache: string; bundleName: string }, ): Promise> { - const checksum = getChecksum(sharedBundles); + const checksum = getChecksum(sharedBundles, fedOptions.dev ? '1' : '0'); const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot; diff --git a/libs/native-federation-core/src/lib/core/load-federation-config.ts b/libs/native-federation-core/src/lib/core/load-federation-config.ts index 19c4db92..77ade144 100644 --- a/libs/native-federation-core/src/lib/core/load-federation-config.ts +++ b/libs/native-federation-core/src/lib/core/load-federation-config.ts @@ -16,7 +16,8 @@ export async function loadFederationConfig( throw new Error('Expected ' + fullConfigPath); } - const config = (await import(fullConfigPath)) as NormalizedFederationConfig; + const config = (await import(fullConfigPath)) + ?.default as NormalizedFederationConfig; if (config.features.ignoreUnusedDeps && !fedOptions.entryPoint) { throw new Error( From 43563a7b3efc62434d088f0fb19f5f6eb572270f Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 07:25:01 +0100 Subject: [PATCH 04/16] fix(native-federation): resolveGlob is now false by default to prevent an overload of bundles being created --- libs/mf/README.md | 30 +++++++++++++++++++ .../src/lib/config/share-utils.ts | 16 +++++----- 2 files changed, 38 insertions(+), 8 deletions(-) diff --git a/libs/mf/README.md b/libs/mf/README.md index 0e0b5963..1096ecb3 100644 --- a/libs/mf/README.md +++ b/libs/mf/README.md @@ -330,6 +330,36 @@ shared: share({ }) ``` +### glob exports + +Since v21 it's also possible to resolve Glob exports by enabling the `globResolve` property: + +```typescript +shared: share({ + "@primeng/themes/aura": { + singleton: true, + strictVersion: true, + requiredVersion: "auto", + includeSecondaries: {resolveGlob: true} + }, + [...] +}) +``` + +This is disabled by default since it will create a bundle of every valid exported file it finds, **Only use this feature in combination with `ignoreUnusedDeps` flag**. If you want to specifically skip certain parts of the glob export, you can also use the wildcard in the skip section: + +```typescript +shared: share({ + "@primeng/themes/aura": { + singleton: true, + strictVersion: true, + requiredVersion: "auto", + includeSecondaries: {skip: "@primeuix/themes/aura/*", resolveGlob: true} + }, + [...] +}) +``` + #### shareAll The `shareAll` helper shares all your dependencies defined in your `package.json`. The `package.json` is look up as described above: diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index 1412e1bd..95eebe5d 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -30,7 +30,7 @@ export const DEFAULT_SECONDARIES_SKIP_LIST = [ ]; type IncludeSecondariesOptions = - | { skip: string | string[]; exhaustive?: boolean } + | { skip: string | string[]; resolveGlob?: boolean } | boolean; type CustomSharedConfig = SharedConfig & { includeSecondaries?: IncludeSecondariesOptions; @@ -161,14 +161,14 @@ function getSecondaries( ): Record | null { let exclude = [...DEFAULT_SECONDARIES_SKIP_LIST]; - let resolveExhaustive = true; + let resolveGlob = false; if (typeof includeSecondaries === 'object') { if (Array.isArray(includeSecondaries.skip)) { exclude = includeSecondaries.skip; } else if (typeof includeSecondaries.skip === 'string') { exclude = [includeSecondaries.skip]; } - if (includeSecondaries.exhaustive === false) resolveExhaustive = false; + resolveGlob = !!includeSecondaries.resolveGlob; } // const libPath = path.join(path.dirname(packagePath), 'node_modules', key); @@ -183,7 +183,7 @@ function getSecondaries( exclude, shareObject, preparedSkipList, - resolveExhaustive, + resolveGlob, ); if (configured) { return configured; @@ -205,7 +205,7 @@ function readConfiguredSecondaries( exclude: string[], shareObject: SharedConfig, preparedSkipList: PreparedSkipList, - resolveExhaustive: boolean, + resolveGlob: boolean, ): Record | null { const libPackageJson = path.join(libPath, 'package.json'); @@ -273,7 +273,7 @@ function readConfiguredSecondaries( secondaryName, entry, { discovered: discoveredFiles, skip: exclude }, - resolveExhaustive, + resolveGlob, ); items.forEach((e) => discoveredFiles.add(typeof e === 'string' ? e : e.value), @@ -307,11 +307,11 @@ function resolveSecondaries( secondaryName: string, entry: string, excludes: { discovered: Set; skip: string[] }, - resolveExhaustive: boolean, + resolveGlob: boolean, ): Array { let items: Array = []; if (key.includes('*')) { - if (!resolveExhaustive) return items; + if (!resolveGlob) return items; const expanded = resolveWildcardKeys(key, entry, libPath); items = expanded .map((e) => ({ From 19b831e2abb2cee989645b0b69e895063fb173c5 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 07:26:09 +0100 Subject: [PATCH 05/16] chore: format files --- .../src/lib/utils/fstart.mjs | 170 ++++++++++-------- .../src/lib/utils/loader-as-data-url.js | 3 +- libs/native-federation/README.md | 13 +- .../src/tools/fstart-as-data-url.ts | 3 +- 4 files changed, 101 insertions(+), 88 deletions(-) diff --git a/libs/native-federation-node/src/lib/utils/fstart.mjs b/libs/native-federation-node/src/lib/utils/fstart.mjs index 43fec55a..2f264b28 100644 --- a/libs/native-federation-node/src/lib/utils/fstart.mjs +++ b/libs/native-federation-node/src/lib/utils/fstart.mjs @@ -1,16 +1,16 @@ // libs/native-federation-node/src/lib/node/init-node-federation.ts -import { register } from "node:module"; -import { pathToFileURL } from "node:url"; -import * as fs2 from "node:fs/promises"; -import * as path2 from "node:path"; +import { register } from 'node:module'; +import { pathToFileURL } from 'node:url'; +import * as fs2 from 'node:fs/promises'; +import * as path2 from 'node:path'; // libs/native-federation-runtime/src/lib/model/global-cache.ts -var nfNamespace = "__NATIVE_FEDERATION__"; +var nfNamespace = '__NATIVE_FEDERATION__'; var global2 = globalThis; global2[nfNamespace] ??= { externals: /* @__PURE__ */ new Map(), remoteNamesToRemote: /* @__PURE__ */ new Map(), - baseUrlToRemoteNames: /* @__PURE__ */ new Map() + baseUrlToRemoteNames: /* @__PURE__ */ new Map(), }; var globalCache = global2[nfNamespace]; @@ -32,7 +32,7 @@ function setExternalUrl(shared, url2) { function mergeImportMaps(map1, map2) { return { imports: { ...map1.imports, ...map2.imports }, - scopes: { ...map1.scopes, ...map2.scopes } + scopes: { ...map1.scopes, ...map2.scopes }, }; } @@ -46,15 +46,15 @@ function addRemote(remoteName, remote) { // libs/native-federation-runtime/src/lib/utils/path-utils.ts function getDirectory(url2) { - const parts = url2.split("/"); + const parts = url2.split('/'); parts.pop(); - return parts.join("/"); + return parts.join('/'); } function joinPaths(path1, path22) { - while (path1.endsWith("/")) { + while (path1.endsWith('/')) { path1 = path1.substring(0, path1.length - 1); } - if (path22.startsWith("./")) { + if (path22.startsWith('./')) { path22 = path22.substring(2, path22.length); } return `${path1}/${path22}`; @@ -63,26 +63,29 @@ function joinPaths(path1, path22) { // libs/native-federation-runtime/src/lib/watch-federation-build.ts function watchFederationBuildCompletion(endpoint) { const eventSource = new EventSource(endpoint); - eventSource.onmessage = function(event) { + eventSource.onmessage = function (event) { const data = JSON.parse(event.data); - if (data.type === "federation-rebuild-complete" /* COMPLETED */) { - console.log("[Federation] Rebuild completed, reloading..."); + if (data.type === 'federation-rebuild-complete' /* COMPLETED */) { + console.log('[Federation] Rebuild completed, reloading...'); window.location.reload(); } }; - eventSource.onerror = function(event) { - console.warn("[Federation] SSE connection error:", event); + eventSource.onerror = function (event) { + console.warn('[Federation] SSE connection error:', event); }; } // libs/native-federation-runtime/src/lib/init-federation.ts -async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) { +async function processRemoteInfos( + remotes, + options = { throwIfRemoteNotFound: false }, +) { const processRemoteInfoPromises = Object.keys(remotes).map( async (remoteName) => { try { let url2 = remotes[remoteName]; if (options.cacheTag) { - const addAppend = remotes[remoteName].includes("?") ? "&" : "?"; + const addAppend = remotes[remoteName].includes('?') ? '&' : '?'; url2 += `${addAppend}t=${options.cacheTag}`; } return await processRemoteInfo(url2, remoteName); @@ -94,12 +97,13 @@ async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: fa console.error(error); return null; } - } + }, ); const remoteImportMaps = await Promise.all(processRemoteInfoPromises); const importMap = remoteImportMaps.reduce( - (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc, - { imports: {}, scopes: {} } + (acc, remoteImportMap) => + remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc, + { imports: {}, scopes: {} }, ); return importMap; } @@ -111,7 +115,7 @@ async function processRemoteInfo(federationInfoUrl, remoteName) { } if (remoteInfo.buildNotificationsEndpoint) { watchFederationBuildCompletion( - baseUrl + remoteInfo.buildNotificationsEndpoint + baseUrl + remoteInfo.buildNotificationsEndpoint, ); } const importMap = createRemoteImportMap(remoteInfo, remoteName, baseUrl); @@ -131,11 +135,12 @@ function processRemoteImports(remoteInfo, baseUrl) { const scopes = {}; const scopedImports = {}; for (const shared of remoteInfo.shared) { - const outFileName = getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName); + const outFileName = + getExternalUrl(shared) ?? joinPaths(baseUrl, shared.outFileName); setExternalUrl(shared, outFileName); scopedImports[shared.packageName] = outFileName; } - scopes[baseUrl + "/"] = scopedImports; + scopes[baseUrl + '/'] = scopedImports; return scopes; } function processExposed(remoteInfo, remoteName, baseUrl) { @@ -147,13 +152,13 @@ function processExposed(remoteInfo, remoteName, baseUrl) { } return imports; } -async function processHostInfo(hostInfo, relBundlesPath = "./") { +async function processHostInfo(hostInfo, relBundlesPath = './') { const imports = hostInfo.shared.reduce( (acc, cur) => ({ ...acc, - [cur.packageName]: relBundlesPath + cur.outFileName + [cur.packageName]: relBundlesPath + cur.outFileName, }), - {} + {}, ); for (const shared of hostInfo.shared) { setExternalUrl(shared, relBundlesPath + shared.outFileName); @@ -162,64 +167,67 @@ async function processHostInfo(hostInfo, relBundlesPath = "./") { } // libs/native-federation-node/src/lib/utils/import-map-loader.js -import path from "path"; -import url from "url"; -import { promises as fs } from "fs"; -var IMPORT_MAP_FILE_NAME = "node.importmap"; +import path from 'path'; +import url from 'url'; +import { promises as fs } from 'fs'; +var IMPORT_MAP_FILE_NAME = 'node.importmap'; var baseURL = url.pathToFileURL(process.cwd()) + path.sep; function resolveAndComposeImportMap(parsed) { if (!isPlainObject(parsed)) { throw Error(`Invalid import map - top level must be an object`); } let sortedAndNormalizedImports = {}; - if (Object.prototype.hasOwnProperty.call(parsed, "imports")) { + if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) { if (!isPlainObject(parsed.imports)) { throw Error(`Invalid import map - "imports" property must be an object`); } sortedAndNormalizedImports = sortAndNormalizeSpecifierMap( parsed.imports, - baseURL + baseURL, ); } let sortedAndNormalizedScopes = {}; - if (Object.prototype.hasOwnProperty.call(parsed, "scopes")) { + if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) { if (!isPlainObject(parsed.scopes)) { throw Error(`Invalid import map - "scopes" property must be an object`); } sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL); } const invalidKeys = Object.keys(parsed).filter( - (key) => key !== "imports" && key !== "scopes" + (key) => key !== 'imports' && key !== 'scopes', ); if (invalidKeys.length > 0) { console.warn( - `Invalid top-level key${invalidKeys.length > 0 ? "s" : ""} in import map - ${invalidKeys.join(", ")}` + `Invalid top-level key${invalidKeys.length > 0 ? 's' : ''} in import map - ${invalidKeys.join(', ')}`, ); } return { imports: sortedAndNormalizedImports, - scopes: sortedAndNormalizedScopes + scopes: sortedAndNormalizedScopes, }; } function sortAndNormalizeSpecifierMap(map, baseURL2) { const normalized = {}; for (let specifierKey in map) { const value = map[specifierKey]; - const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL2); + const normalizedSpecifierKey = normalizeSpecifierKey( + specifierKey, + baseURL2, + ); if (normalizedSpecifierKey === null) { continue; } let addressURL = parseURLLikeSpecifier(value, baseURL2); if (addressURL === null) { console.warn( - `Invalid URL address for import map specifier '${specifierKey}'` + `Invalid URL address for import map specifier '${specifierKey}'`, ); normalized[normalizedSpecifierKey] = null; continue; } - if (specifierKey.endsWith("/") && !addressURL.endsWith("/")) { + if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) { console.warn( - `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address` + `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`, ); normalized[normalizedSpecifierKey] = null; continue; @@ -229,14 +237,17 @@ function sortAndNormalizeSpecifierMap(map, baseURL2) { return normalized; } function normalizeSpecifierKey(key) { - if (key === "") { + if (key === '') { console.warn(`Specifier keys in import maps may not be the empty string`); return null; } return parseURLLikeSpecifier(key, baseURL) || key; } function parseURLLikeSpecifier(specifier, baseURL2) { - const useBaseUrlAsParent = specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../"); + const useBaseUrlAsParent = + specifier.startsWith('/') || + specifier.startsWith('./') || + specifier.startsWith('../'); try { return new URL(specifier, useBaseUrlAsParent ? baseURL2 : void 0).href; } catch { @@ -249,7 +260,7 @@ function sortAndNormalizeScopes(map, baseURL2) { const potentialSpecifierMap = map[scopePrefix]; if (!isPlainObject(potentialSpecifierMap)) { throw TypeError( - `The value of scope ${scopePrefix} must be a JSON object` + `The value of scope ${scopePrefix} must be a JSON object`, ); } let scopePrefixURL; @@ -257,13 +268,13 @@ function sortAndNormalizeScopes(map, baseURL2) { scopePrefixURL = new URL(scopePrefix, baseURL2).href; } catch { console.warn( - `Scope prefix URL '${scopePrefix}' was not parseable in import map` + `Scope prefix URL '${scopePrefix}' was not parseable in import map`, ); continue; } normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap( potentialSpecifierMap, - baseURL2 + baseURL2, ); } return normalized; @@ -286,7 +297,7 @@ async function getImportMapPromise() { json = await JSON.parse(str); } catch (err) { throw Error( - `Import map at ${importMapPath} contains invalid json: ${err.message}` + `Import map at ${importMapPath} contains invalid json: ${err.message}`, ); } return resolveAndComposeImportMap(json); @@ -302,41 +313,45 @@ function emptyMap() { } // libs/native-federation-node/src/lib/utils/loader-as-data-url.js -var resolver = "import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
"; +var resolver = + 'import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
'; // libs/native-federation-node/src/lib/node/init-node-federation.ts var defaultOptions = { remotesOrManifestUrl: {}, - relBundlePath: "../browser", - throwIfRemoteNotFound: false + relBundlePath: '../browser', + throwIfRemoteNotFound: false, }; async function initNodeFederation(options) { const mergedOptions = { ...defaultOptions, ...options }; const importMap = await createNodeImportMap(mergedOptions); await writeImportMap(importMap); await writeResolver(); - register(pathToFileURL("./federation-resolver.mjs").href); + register(pathToFileURL('./federation-resolver.mjs').href); } async function createNodeImportMap(options) { const { remotesOrManifestUrl, relBundlePath } = options; - const remotes = typeof remotesOrManifestUrl === "object" ? remotesOrManifestUrl : await loadFsManifest(remotesOrManifestUrl); + const remotes = + typeof remotesOrManifestUrl === 'object' + ? remotesOrManifestUrl + : await loadFsManifest(remotesOrManifestUrl); const hostInfo = await loadFsFederationInfo(relBundlePath); - const hostImportMap = await processHostInfo(hostInfo, "./" + relBundlePath); + const hostImportMap = await processHostInfo(hostInfo, './' + relBundlePath); const remotesImportMap = await processRemoteInfos(remotes, { throwIfRemoteNotFound: options.throwIfRemoteNotFound, - cacheTag: options.cacheTag + cacheTag: options.cacheTag, }); const importMap = mergeImportMaps(hostImportMap, remotesImportMap); return importMap; } async function loadFsManifest(manifestUrl) { - const content = await fs2.readFile(manifestUrl, "utf-8"); + const content = await fs2.readFile(manifestUrl, 'utf-8'); const manifest = JSON.parse(content); return manifest; } async function loadFsFederationInfo(relBundlePath) { - const manifestPath = path2.join(relBundlePath, "remoteEntry.json"); - const content = await fs2.readFile(manifestPath, "utf-8"); + const manifestPath = path2.join(relBundlePath, 'remoteEntry.json'); + const content = await fs2.readFile(manifestPath, 'utf-8'); const manifest = JSON.parse(content); return manifest; } @@ -344,31 +359,31 @@ async function writeImportMap(map) { await fs2.writeFile( IMPORT_MAP_FILE_NAME, JSON.stringify(map, null, 2), - "utf-8" + 'utf-8', ); } async function writeResolver() { - const buffer = Buffer.from(resolver, "base64"); - await fs2.writeFile("federation-resolver.mjs", buffer, "utf-8"); + const buffer = Buffer.from(resolver, 'base64'); + await fs2.writeFile('federation-resolver.mjs', buffer, 'utf-8'); } // libs/native-federation-node/src/lib/utils/fstart-args-parser.ts -import * as fs3 from "node:fs"; +import * as fs3 from 'node:fs'; var defaultArgs = { - entry: "./server.mjs", - remotesOrManifestUrl: "../browser/federation.manifest.json", - relBundlePath: "../browser/" + entry: './server.mjs', + remotesOrManifestUrl: '../browser/federation.manifest.json', + relBundlePath: '../browser/', }; function parseFStartArgs() { const args2 = { - entry: "", - remotesOrManifestUrl: "", - relBundlePath: "" + entry: '', + remotesOrManifestUrl: '', + relBundlePath: '', }; - let key = ""; + let key = ''; for (let i = 2; i < process.argv.length; i++) { const cand = process.argv[i]; - if (cand.startsWith("--")) { + if (cand.startsWith('--')) { const candKey = cand.substring(2); if (defaultArgs[candKey]) { key = candKey; @@ -378,7 +393,7 @@ function parseFStartArgs() { } } else if (key) { args2[key] = cand; - key = ""; + key = ''; } else { console.error(`unreladed value ${cand}!`); exitWithUsage(defaultArgs); @@ -389,24 +404,25 @@ function parseFStartArgs() { } function applyDefaultArgs(args2) { if (args2.relBundlePath && !args2.remotesOrManifestUrl) { - const cand = defaultArgs.relBundlePath + "federation.manifest.json"; + const cand = defaultArgs.relBundlePath + 'federation.manifest.json'; if (fs3.existsSync(cand)) { args2.remotesOrManifestUrl = cand; } } args2.entry = args2.entry || defaultArgs.entry; args2.relBundlePath = args2.relBundlePath || defaultArgs.relBundlePath; - args2.remotesOrManifestUrl = args2.remotesOrManifestUrl || defaultArgs.remotesOrManifestUrl; + args2.remotesOrManifestUrl = + args2.remotesOrManifestUrl || defaultArgs.remotesOrManifestUrl; if (!fs3.existsSync(args2.remotesOrManifestUrl)) { args2.remotesOrManifestUrl = void 0; } } function exitWithUsage(defaultArgs2) { - let args2 = ""; + let args2 = ''; for (const key in defaultArgs2) { args2 += `[--${key} ${defaultArgs2[key]}] `; } - console.log("usage: nfstart " + args2); + console.log('usage: nfstart ' + args2); process.exit(1); } @@ -414,8 +430,10 @@ function exitWithUsage(defaultArgs2) { var args = parseFStartArgs(); (async () => { await initNodeFederation({ - ...args.remotesOrManifestUrl ? { remotesOrManifestUrl: args.remotesOrManifestUrl } : {}, - relBundlePath: args.relBundlePath + ...(args.remotesOrManifestUrl + ? { remotesOrManifestUrl: args.remotesOrManifestUrl } + : {}), + relBundlePath: args.relBundlePath, }); await import(args.entry); })(); diff --git a/libs/native-federation-node/src/lib/utils/loader-as-data-url.js b/libs/native-federation-node/src/lib/utils/loader-as-data-url.js index 39e68018..425926fb 100644 --- a/libs/native-federation-node/src/lib/utils/loader-as-data-url.js +++ b/libs/native-federation-node/src/lib/utils/loader-as-data-url.js @@ -1 +1,2 @@ -export const resolver = "import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
"; +export const resolver = + 'import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
'; diff --git a/libs/native-federation/README.md b/libs/native-federation/README.md index 2c322301..251a06f3 100644 --- a/libs/native-federation/README.md +++ b/libs/native-federation/README.md @@ -173,10 +173,7 @@ A dynamic host reads the configuration data at runtime from a `.json` file. The host configuration (`projects/shell/federation.config.js`) looks like what you know from our Module Federation plugin: ```javascript -const { - withNativeFederation, - shareAll, -} = require('@angular-architects/native-federation/config'); +const { withNativeFederation, shareAll } = require('@angular-architects/native-federation/config'); module.exports = withNativeFederation({ name: 'my-host', @@ -205,10 +202,7 @@ module.exports = withNativeFederation({ Also, the remote configuration (`projects/mfe1/federation.config.js`) looks familiar: ```javascript -const { - withNativeFederation, - shareAll, -} = require('@angular-architects/native-federation/config'); +const { withNativeFederation, shareAll } = require('@angular-architects/native-federation/config'); module.exports = withNativeFederation({ name: 'mfe1', @@ -307,8 +301,7 @@ export const APP_ROUTES: Routes = [ // Add this route: { path: 'flights', - loadComponent: () => - loadRemoteModule('mfe1', './Component').then((m) => m.AppComponent), + loadComponent: () => loadRemoteModule('mfe1', './Component').then((m) => m.AppComponent), }, { diff --git a/libs/native-federation/src/tools/fstart-as-data-url.ts b/libs/native-federation/src/tools/fstart-as-data-url.ts index 8627a352..21d8317b 100644 --- a/libs/native-federation/src/tools/fstart-as-data-url.ts +++ b/libs/native-federation/src/tools/fstart-as-data-url.ts @@ -1 +1,2 @@ -export const fstart = "// libs/native-federation-node/src/lib/node/init-node-federation.ts
import { register } from "node:module";
import { pathToFileURL } from "node:url";
import * as fs2 from "node:fs/promises";
import * as path2 from "node:path";

// libs/native-federation-runtime/src/lib/model/global-cache.ts
var nfNamespace = "__NATIVE_FEDERATION__";
var global2 = globalThis;
global2[nfNamespace] ??= {
  externals: /* @__PURE__ */ new Map(),
  remoteNamesToRemote: /* @__PURE__ */ new Map(),
  baseUrlToRemoteNames: /* @__PURE__ */ new Map()
};
var globalCache = global2[nfNamespace];

// libs/native-federation-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, url2) {
  const packageKey = getExternalKey(shared);
  externals.set(packageKey, url2);
}

// libs/native-federation-runtime/src/lib/model/import-map.ts
function mergeImportMaps(map1, map2) {
  return {
    imports: { ...map1.imports, ...map2.imports },
    scopes: { ...map1.scopes, ...map2.scopes }
  };
}

// libs/native-federation-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);
}

// libs/native-federation-runtime/src/lib/utils/path-utils.ts
function getDirectory(url2) {
  const parts = url2.split("/");
  parts.pop();
  return parts.join("/");
}
function joinPaths(path1, path22) {
  while (path1.endsWith("/")) {
    path1 = path1.substring(0, path1.length - 1);
  }
  if (path22.startsWith("./")) {
    path22 = path22.substring(2, path22.length);
  }
  return `${path1}/${path22}`;
}

// libs/native-federation-runtime/src/lib/watch-federation-build.ts
function watchFederationBuildCompletion(endpoint) {
  const eventSource = new EventSource(endpoint);
  eventSource.onmessage = function(event) {
    const data = JSON.parse(event.data);
    if (data.type === "federation-rebuild-complete" /* COMPLETED */) {
      console.log("[Federation] Rebuild completed, reloading...");
      window.location.reload();
    }
  };
  eventSource.onerror = function(event) {
    console.warn("[Federation] SSE connection error:", event);
  };
}

// libs/native-federation-runtime/src/lib/init-federation.ts
async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) {
  const processRemoteInfoPromises = Object.keys(remotes).map(
    async (remoteName) => {
      try {
        let url2 = remotes[remoteName];
        if (options.cacheTag) {
          const addAppend = remotes[remoteName].includes("?") ? "&" : "?";
          url2 += `${addAppend}t=${options.cacheTag}`;
        }
        return await processRemoteInfo(url2, remoteName);
      } catch (e) {
        const error = `Error loading remote entry for ${remoteName} from file ${remotes[remoteName]}`;
        if (options.throwIfRemoteNotFound) {
          throw new Error(error);
        }
        console.error(error);
        return null;
      }
    }
  );
  const remoteImportMaps = await Promise.all(processRemoteInfoPromises);
  const importMap = remoteImportMaps.reduce(
    (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc,
    { imports: {}, scopes: {} }
  );
  return importMap;
}
async function processRemoteInfo(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(url2) {
  const info = await fetch(url2).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: {} };
}

// libs/native-federation-node/src/lib/utils/import-map-loader.js
import path from "path";
import url from "url";
import { promises as fs } from "fs";
var IMPORT_MAP_FILE_NAME = "node.importmap";
var baseURL = url.pathToFileURL(process.cwd()) + path.sep;
function resolveAndComposeImportMap(parsed) {
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }
  let sortedAndNormalizedImports = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "imports")) {
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL
    );
  }
  let sortedAndNormalizedScopes = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "scopes")) {
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== "imports" && key !== "scopes"
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${invalidKeys.length > 0 ? "s" : ""} in import map - ${invalidKeys.join(", ")}`
    );
  }
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes
  };
}
function sortAndNormalizeSpecifierMap(map, baseURL2) {
  const normalized = {};
  for (let specifierKey in map) {
    const value = map[specifierKey];
    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL2);
    if (normalizedSpecifierKey === null) {
      continue;
    }
    let addressURL = parseURLLikeSpecifier(value, baseURL2);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    if (specifierKey.endsWith("/") && !addressURL.endsWith("/")) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    normalized[normalizedSpecifierKey] = addressURL;
  }
  return normalized;
}
function normalizeSpecifierKey(key) {
  if (key === "") {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }
  return parseURLLikeSpecifier(key, baseURL) || key;
}
function parseURLLikeSpecifier(specifier, baseURL2) {
  const useBaseUrlAsParent = specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../");
  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL2 : void 0).href;
  } catch {
    return null;
  }
}
function sortAndNormalizeScopes(map, baseURL2) {
  let normalized = {};
  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`
      );
    }
    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL2).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`
      );
      continue;
    }
    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL2
    );
  }
  return normalized;
}
function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}
var importMapPromise = getImportMapPromise();
async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);
  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }
  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`
    );
  }
  return resolveAndComposeImportMap(json);
}
global.nodeLoader = global.nodeLoader || {};
global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};
function emptyMap() {
  return { imports: {}, scopes: {} };
}

// libs/native-federation-node/src/lib/utils/loader-as-data-url.js
var resolver = "import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
";

// libs/native-federation-node/src/lib/node/init-node-federation.ts
var defaultOptions = {
  remotesOrManifestUrl: {},
  relBundlePath: "../browser",
  throwIfRemoteNotFound: false
};
async function initNodeFederation(options) {
  const mergedOptions = { ...defaultOptions, ...options };
  const importMap = await createNodeImportMap(mergedOptions);
  await writeImportMap(importMap);
  await writeResolver();
  register(pathToFileURL("./federation-resolver.mjs").href);
}
async function createNodeImportMap(options) {
  const { remotesOrManifestUrl, relBundlePath } = options;
  const remotes = typeof remotesOrManifestUrl === "object" ? remotesOrManifestUrl : await loadFsManifest(remotesOrManifestUrl);
  const hostInfo = await loadFsFederationInfo(relBundlePath);
  const hostImportMap = await processHostInfo(hostInfo, "./" + relBundlePath);
  const remotesImportMap = await processRemoteInfos(remotes, {
    throwIfRemoteNotFound: options.throwIfRemoteNotFound,
    cacheTag: options.cacheTag
  });
  const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
  return importMap;
}
async function loadFsManifest(manifestUrl) {
  const content = await fs2.readFile(manifestUrl, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function loadFsFederationInfo(relBundlePath) {
  const manifestPath = path2.join(relBundlePath, "remoteEntry.json");
  const content = await fs2.readFile(manifestPath, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function writeImportMap(map) {
  await fs2.writeFile(
    IMPORT_MAP_FILE_NAME,
    JSON.stringify(map, null, 2),
    "utf-8"
  );
}
async function writeResolver() {
  const buffer = Buffer.from(resolver, "base64");
  await fs2.writeFile("federation-resolver.mjs", buffer, "utf-8");
}

// libs/native-federation-node/src/lib/utils/fstart-args-parser.ts
import * as fs3 from "node:fs";
var defaultArgs = {
  entry: "./server.mjs",
  remotesOrManifestUrl: "../browser/federation.manifest.json",
  relBundlePath: "../browser/"
};
function parseFStartArgs() {
  const args2 = {
    entry: "",
    remotesOrManifestUrl: "",
    relBundlePath: ""
  };
  let key = "";
  for (let i = 2; i < process.argv.length; i++) {
    const cand = process.argv[i];
    if (cand.startsWith("--")) {
      const candKey = cand.substring(2);
      if (defaultArgs[candKey]) {
        key = candKey;
      } else {
        console.error(`switch ${cand} not supported!`);
        exitWithUsage(defaultArgs);
      }
    } else if (key) {
      args2[key] = cand;
      key = "";
    } else {
      console.error(`unreladed value ${cand}!`);
      exitWithUsage(defaultArgs);
    }
  }
  applyDefaultArgs(args2);
  return args2;
}
function applyDefaultArgs(args2) {
  if (args2.relBundlePath && !args2.remotesOrManifestUrl) {
    const cand = defaultArgs.relBundlePath + "federation.manifest.json";
    if (fs3.existsSync(cand)) {
      args2.remotesOrManifestUrl = cand;
    }
  }
  args2.entry = args2.entry || defaultArgs.entry;
  args2.relBundlePath = args2.relBundlePath || defaultArgs.relBundlePath;
  args2.remotesOrManifestUrl = args2.remotesOrManifestUrl || defaultArgs.remotesOrManifestUrl;
  if (!fs3.existsSync(args2.remotesOrManifestUrl)) {
    args2.remotesOrManifestUrl = void 0;
  }
}
function exitWithUsage(defaultArgs2) {
  let args2 = "";
  for (const key in defaultArgs2) {
    args2 += `[--${key} ${defaultArgs2[key]}] `;
  }
  console.log("usage: nfstart " + args2);
  process.exit(1);
}

// libs/native-federation-node/src/lib/utils/fstart.ts
var args = parseFStartArgs();
(async () => {
  await initNodeFederation({
    ...args.remotesOrManifestUrl ? { remotesOrManifestUrl: args.remotesOrManifestUrl } : {},
    relBundlePath: args.relBundlePath
  });
  await import(args.entry);
})();
"; +export const fstart = + '// libs/native-federation-node/src/lib/node/init-node-federation.ts
import { register } from "node:module";
import { pathToFileURL } from "node:url";
import * as fs2 from "node:fs/promises";
import * as path2 from "node:path";

// libs/native-federation-runtime/src/lib/model/global-cache.ts
var nfNamespace = "__NATIVE_FEDERATION__";
var global2 = globalThis;
global2[nfNamespace] ??= {
  externals: /* @__PURE__ */ new Map(),
  remoteNamesToRemote: /* @__PURE__ */ new Map(),
  baseUrlToRemoteNames: /* @__PURE__ */ new Map()
};
var globalCache = global2[nfNamespace];

// libs/native-federation-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, url2) {
  const packageKey = getExternalKey(shared);
  externals.set(packageKey, url2);
}

// libs/native-federation-runtime/src/lib/model/import-map.ts
function mergeImportMaps(map1, map2) {
  return {
    imports: { ...map1.imports, ...map2.imports },
    scopes: { ...map1.scopes, ...map2.scopes }
  };
}

// libs/native-federation-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);
}

// libs/native-federation-runtime/src/lib/utils/path-utils.ts
function getDirectory(url2) {
  const parts = url2.split("/");
  parts.pop();
  return parts.join("/");
}
function joinPaths(path1, path22) {
  while (path1.endsWith("/")) {
    path1 = path1.substring(0, path1.length - 1);
  }
  if (path22.startsWith("./")) {
    path22 = path22.substring(2, path22.length);
  }
  return `${path1}/${path22}`;
}

// libs/native-federation-runtime/src/lib/watch-federation-build.ts
function watchFederationBuildCompletion(endpoint) {
  const eventSource = new EventSource(endpoint);
  eventSource.onmessage = function(event) {
    const data = JSON.parse(event.data);
    if (data.type === "federation-rebuild-complete" /* COMPLETED */) {
      console.log("[Federation] Rebuild completed, reloading...");
      window.location.reload();
    }
  };
  eventSource.onerror = function(event) {
    console.warn("[Federation] SSE connection error:", event);
  };
}

// libs/native-federation-runtime/src/lib/init-federation.ts
async function processRemoteInfos(remotes, options = { throwIfRemoteNotFound: false }) {
  const processRemoteInfoPromises = Object.keys(remotes).map(
    async (remoteName) => {
      try {
        let url2 = remotes[remoteName];
        if (options.cacheTag) {
          const addAppend = remotes[remoteName].includes("?") ? "&" : "?";
          url2 += `${addAppend}t=${options.cacheTag}`;
        }
        return await processRemoteInfo(url2, remoteName);
      } catch (e) {
        const error = `Error loading remote entry for ${remoteName} from file ${remotes[remoteName]}`;
        if (options.throwIfRemoteNotFound) {
          throw new Error(error);
        }
        console.error(error);
        return null;
      }
    }
  );
  const remoteImportMaps = await Promise.all(processRemoteInfoPromises);
  const importMap = remoteImportMaps.reduce(
    (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc,
    { imports: {}, scopes: {} }
  );
  return importMap;
}
async function processRemoteInfo(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(url2) {
  const info = await fetch(url2).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: {} };
}

// libs/native-federation-node/src/lib/utils/import-map-loader.js
import path from "path";
import url from "url";
import { promises as fs } from "fs";
var IMPORT_MAP_FILE_NAME = "node.importmap";
var baseURL = url.pathToFileURL(process.cwd()) + path.sep;
function resolveAndComposeImportMap(parsed) {
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }
  let sortedAndNormalizedImports = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "imports")) {
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL
    );
  }
  let sortedAndNormalizedScopes = {};
  if (Object.prototype.hasOwnProperty.call(parsed, "scopes")) {
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== "imports" && key !== "scopes"
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${invalidKeys.length > 0 ? "s" : ""} in import map - ${invalidKeys.join(", ")}`
    );
  }
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes
  };
}
function sortAndNormalizeSpecifierMap(map, baseURL2) {
  const normalized = {};
  for (let specifierKey in map) {
    const value = map[specifierKey];
    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL2);
    if (normalizedSpecifierKey === null) {
      continue;
    }
    let addressURL = parseURLLikeSpecifier(value, baseURL2);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    if (specifierKey.endsWith("/") && !addressURL.endsWith("/")) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }
    normalized[normalizedSpecifierKey] = addressURL;
  }
  return normalized;
}
function normalizeSpecifierKey(key) {
  if (key === "") {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }
  return parseURLLikeSpecifier(key, baseURL) || key;
}
function parseURLLikeSpecifier(specifier, baseURL2) {
  const useBaseUrlAsParent = specifier.startsWith("/") || specifier.startsWith("./") || specifier.startsWith("../");
  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL2 : void 0).href;
  } catch {
    return null;
  }
}
function sortAndNormalizeScopes(map, baseURL2) {
  let normalized = {};
  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`
      );
    }
    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL2).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`
      );
      continue;
    }
    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL2
    );
  }
  return normalized;
}
function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}
var importMapPromise = getImportMapPromise();
async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);
  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }
  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`
    );
  }
  return resolveAndComposeImportMap(json);
}
global.nodeLoader = global.nodeLoader || {};
global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};
function emptyMap() {
  return { imports: {}, scopes: {} };
}

// libs/native-federation-node/src/lib/utils/loader-as-data-url.js
var resolver = "import path from 'path';
import url from 'url';
import { promises as fs } from 'fs';

export const IMPORT_MAP_FILE_NAME = 'node.importmap';

const baseURL = url.pathToFileURL(process.cwd()) + path.sep;

// https://wicg.github.io/import-maps/#new-resolve-algorithm
export function resolveSpecifier(importMap, specifier, parentURL) {
  let currentBaseURL;
  if (parentURL) {
    const lastSlashIndex = parentURL.lastIndexOf(path.sep);
    currentBaseURL = parentURL.slice(0, lastSlashIndex + 1);
  } else {
    currentBaseURL = baseURL;
  }
  const normalizedSpecifier =
    parseURLLikeSpecifier(specifier, currentBaseURL) || specifier;
  for (let scopePrefix in importMap.scopes) {
    if (
      scopePrefix === currentBaseURL ||
      (scopePrefix.endsWith('/') && currentBaseURL.startsWith(scopePrefix))
    ) {
      const scopeImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.scopes[scopePrefix],
      );
      if (scopeImportsMatch) {
        return scopeImportsMatch;
      }
    } else {
      const topLevelImportsMatch = resolveImportsMatch(
        normalizedSpecifier,
        importMap.imports,
      );
      if (topLevelImportsMatch) {
        return topLevelImportsMatch;
      }
    }
  }

  return resolveImportsMatch(normalizedSpecifier, importMap.imports);
}

// https://wicg.github.io/import-maps/#resolve-an-imports-match
function resolveImportsMatch(normalizedSpecifier, specifierMap) {
  for (let specifierKey in specifierMap) {
    const resolutionResult = specifierMap[specifierKey];

    if (specifierKey === normalizedSpecifier) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      return resolutionResult;
    } else if (
      specifierKey.endsWith('/') &&
      normalizedSpecifier.startsWith(specifierKey)
    ) {
      if (resolutionResult === null) {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to a null entry`,
        );
      }
      const afterPrefix = normalizedSpecifier.slice(specifierKey.length);
      try {
        return new URL(afterPrefix, resolutionResult).href;
      } catch {
        throw TypeError(
          `The import map resolution of ${specifierKey} failed due to URL parse failure`,
        );
      }
    }
  }

  return null;
}

// https://wicg.github.io/import-maps/#parsing
export function resolveAndComposeImportMap(parsed) {
  // Step 2
  if (!isPlainObject(parsed)) {
    throw Error(`Invalid import map - top level must be an object`);
  }

  // Step 3
  let sortedAndNormalizedImports = {};

  // Step 4
  if (Object.prototype.hasOwnProperty.call(parsed, 'imports')) {
    // Step 4.1
    if (!isPlainObject(parsed.imports)) {
      throw Error(`Invalid import map - "imports" property must be an object`);
    }

    // Step 4.2
    sortedAndNormalizedImports = sortAndNormalizeSpecifierMap(
      parsed.imports,
      baseURL,
    );
  }

  // Step 5
  let sortedAndNormalizedScopes = {};

  // Step 6
  if (Object.prototype.hasOwnProperty.call(parsed, 'scopes')) {
    // Step 6.1
    if (!isPlainObject(parsed.scopes)) {
      throw Error(`Invalid import map - "scopes" property must be an object`);
    }

    // Step 6.2
    sortedAndNormalizedScopes = sortAndNormalizeScopes(parsed.scopes, baseURL);
  }

  // Step 7
  const invalidKeys = Object.keys(parsed).filter(
    (key) => key !== 'imports' && key !== 'scopes',
  );
  if (invalidKeys.length > 0) {
    console.warn(
      `Invalid top-level key${
        invalidKeys.length > 0 ? 's' : ''
      } in import map - ${invalidKeys.join(', ')}`,
    );
  }

  // Step 8
  return {
    imports: sortedAndNormalizedImports,
    scopes: sortedAndNormalizedScopes,
  };
}

// https://wicg.github.io/import-maps/#sort-and-normalize-a-specifier-map
function sortAndNormalizeSpecifierMap(map, baseURL) {
  const normalized = {};

  for (let specifierKey in map) {
    const value = map[specifierKey];

    const normalizedSpecifierKey = normalizeSpecifierKey(specifierKey, baseURL);
    if (normalizedSpecifierKey === null) {
      continue;
    }

    let addressURL = parseURLLikeSpecifier(value, baseURL);
    if (addressURL === null) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}'`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    if (specifierKey.endsWith('/') && !addressURL.endsWith('/')) {
      console.warn(
        `Invalid URL address for import map specifier '${specifierKey}' - since the specifier ends in slash, so must the address`,
      );
      normalized[normalizedSpecifierKey] = null;
      continue;
    }

    normalized[normalizedSpecifierKey] = addressURL;
  }

  return normalized;
}

// https://wicg.github.io/import-maps/#normalize-a-specifier-key
function normalizeSpecifierKey(key) {
  if (key === '') {
    console.warn(`Specifier keys in import maps may not be the empty string`);
    return null;
  }

  return parseURLLikeSpecifier(key, baseURL) || key;
}

// https://wicg.github.io/import-maps/#parse-a-url-like-import-specifier
function parseURLLikeSpecifier(specifier, baseURL) {
  const useBaseUrlAsParent =
    specifier.startsWith('/') ||
    specifier.startsWith('./') ||
    specifier.startsWith('../');

  try {
    return new URL(specifier, useBaseUrlAsParent ? baseURL : undefined).href;
  } catch {
    return null;
  }
}

// https://wicg.github.io/import-maps/#sort-and-normalize-scopes
function sortAndNormalizeScopes(map, baseURL) {
  let normalized = {};

  for (let scopePrefix in map) {
    const potentialSpecifierMap = map[scopePrefix];
    if (!isPlainObject(potentialSpecifierMap)) {
      throw TypeError(
        `The value of scope ${scopePrefix} must be a JSON object`,
      );
    }

    let scopePrefixURL;
    try {
      scopePrefixURL = new URL(scopePrefix, baseURL).href;
    } catch {
      console.warn(
        `Scope prefix URL '${scopePrefix}' was not parseable in import map`,
      );
      continue;
    }

    normalized[scopePrefixURL] = sortAndNormalizeSpecifierMap(
      potentialSpecifierMap,
      baseURL,
    );
  }

  return normalized;
}

function isPlainObject(obj) {
  return obj === Object(obj) && !Array.isArray(obj);
}

// ---

let importMapPromise = getImportMapPromise();

export async function resolve(specifier, context, defaultResolve) {
  const { parentURL = null } = context;
  const importMap = await importMapPromise;
  const importMapUrl = resolveSpecifier(importMap, specifier, parentURL);

  return defaultResolve(importMapUrl ?? specifier, context, defaultResolve);
}

export async function load(url, context, defaultLoad) {
  if (url.startsWith('http://') || url.startsWith('https://')) {
    const res = await fetch(url);
    if (!res.ok) {
      throw new Error(`Failed to fetch module from ${url}`);
    }
    const source = await res.text();
    return {
      shortCircuit: true,
      format: 'module',
      source,
    };
  }

  if (!url.startsWith('node:')) {
    context.format = 'module';
  }

  return defaultLoad(url, context, defaultLoad);
}

async function getImportMapPromise() {
  const relativePath = process.env.IMPORT_MAP_PATH || IMPORT_MAP_FILE_NAME;
  const importMapPath = path.resolve(process.cwd(), relativePath);

  let str;
  try {
    str = await fs.readFile(importMapPath);
  } catch (err) {
    return emptyMap();
  }

  let json;
  try {
    json = await JSON.parse(str);
  } catch (err) {
    throw Error(
      `Import map at ${importMapPath} contains invalid json: ${err.message}`,
    );
  }

  return resolveAndComposeImportMap(json);
}

global.nodeLoader = global.nodeLoader || {};

global.nodeLoader.setImportMapPromise = function setImportMapPromise(promise) {
  importMapPromise = promise.then((map) => {
    return resolveAndComposeImportMap(map);
  });
};

function emptyMap() {
  return { imports: {}, scopes: {} };
}
";

// libs/native-federation-node/src/lib/node/init-node-federation.ts
var defaultOptions = {
  remotesOrManifestUrl: {},
  relBundlePath: "../browser",
  throwIfRemoteNotFound: false
};
async function initNodeFederation(options) {
  const mergedOptions = { ...defaultOptions, ...options };
  const importMap = await createNodeImportMap(mergedOptions);
  await writeImportMap(importMap);
  await writeResolver();
  register(pathToFileURL("./federation-resolver.mjs").href);
}
async function createNodeImportMap(options) {
  const { remotesOrManifestUrl, relBundlePath } = options;
  const remotes = typeof remotesOrManifestUrl === "object" ? remotesOrManifestUrl : await loadFsManifest(remotesOrManifestUrl);
  const hostInfo = await loadFsFederationInfo(relBundlePath);
  const hostImportMap = await processHostInfo(hostInfo, "./" + relBundlePath);
  const remotesImportMap = await processRemoteInfos(remotes, {
    throwIfRemoteNotFound: options.throwIfRemoteNotFound,
    cacheTag: options.cacheTag
  });
  const importMap = mergeImportMaps(hostImportMap, remotesImportMap);
  return importMap;
}
async function loadFsManifest(manifestUrl) {
  const content = await fs2.readFile(manifestUrl, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function loadFsFederationInfo(relBundlePath) {
  const manifestPath = path2.join(relBundlePath, "remoteEntry.json");
  const content = await fs2.readFile(manifestPath, "utf-8");
  const manifest = JSON.parse(content);
  return manifest;
}
async function writeImportMap(map) {
  await fs2.writeFile(
    IMPORT_MAP_FILE_NAME,
    JSON.stringify(map, null, 2),
    "utf-8"
  );
}
async function writeResolver() {
  const buffer = Buffer.from(resolver, "base64");
  await fs2.writeFile("federation-resolver.mjs", buffer, "utf-8");
}

// libs/native-federation-node/src/lib/utils/fstart-args-parser.ts
import * as fs3 from "node:fs";
var defaultArgs = {
  entry: "./server.mjs",
  remotesOrManifestUrl: "../browser/federation.manifest.json",
  relBundlePath: "../browser/"
};
function parseFStartArgs() {
  const args2 = {
    entry: "",
    remotesOrManifestUrl: "",
    relBundlePath: ""
  };
  let key = "";
  for (let i = 2; i < process.argv.length; i++) {
    const cand = process.argv[i];
    if (cand.startsWith("--")) {
      const candKey = cand.substring(2);
      if (defaultArgs[candKey]) {
        key = candKey;
      } else {
        console.error(`switch ${cand} not supported!`);
        exitWithUsage(defaultArgs);
      }
    } else if (key) {
      args2[key] = cand;
      key = "";
    } else {
      console.error(`unreladed value ${cand}!`);
      exitWithUsage(defaultArgs);
    }
  }
  applyDefaultArgs(args2);
  return args2;
}
function applyDefaultArgs(args2) {
  if (args2.relBundlePath && !args2.remotesOrManifestUrl) {
    const cand = defaultArgs.relBundlePath + "federation.manifest.json";
    if (fs3.existsSync(cand)) {
      args2.remotesOrManifestUrl = cand;
    }
  }
  args2.entry = args2.entry || defaultArgs.entry;
  args2.relBundlePath = args2.relBundlePath || defaultArgs.relBundlePath;
  args2.remotesOrManifestUrl = args2.remotesOrManifestUrl || defaultArgs.remotesOrManifestUrl;
  if (!fs3.existsSync(args2.remotesOrManifestUrl)) {
    args2.remotesOrManifestUrl = void 0;
  }
}
function exitWithUsage(defaultArgs2) {
  let args2 = "";
  for (const key in defaultArgs2) {
    args2 += `[--${key} ${defaultArgs2[key]}] `;
  }
  console.log("usage: nfstart " + args2);
  process.exit(1);
}

// libs/native-federation-node/src/lib/utils/fstart.ts
var args = parseFStartArgs();
(async () => {
  await initNodeFederation({
    ...args.remotesOrManifestUrl ? { remotesOrManifestUrl: args.remotesOrManifestUrl } : {},
    relBundlePath: args.relBundlePath
  });
  await import(args.entry);
})();
'; From 89cfec029588cb8401237e0e2a0664dfacf6998b Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 09:33:20 +0100 Subject: [PATCH 06/16] fix(native-federation): Bug where wrong variable was used as export --- .../native-federation-core/src/lib/config/share-utils.ts | 2 +- .../native-federation-core/src/lib/utils/package-info.ts | 9 +++------ 2 files changed, 4 insertions(+), 7 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index 95eebe5d..8b63cad7 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -30,7 +30,7 @@ export const DEFAULT_SECONDARIES_SKIP_LIST = [ ]; type IncludeSecondariesOptions = - | { skip: string | string[]; resolveGlob?: boolean } + | { skip: string | string[]; resolveGlob?: boolean; shareAll?: boolean } | boolean; type CustomSharedConfig = SharedConfig & { includeSecondaries?: IncludeSecondariesOptions; diff --git a/libs/native-federation-core/src/lib/utils/package-info.ts b/libs/native-federation-core/src/lib/utils/package-info.ts index 0c58bc56..2192d001 100644 --- a/libs/native-federation-core/src/lib/utils/package-info.ts +++ b/libs/native-federation-core/src/lib/utils/package-info.ts @@ -270,16 +270,13 @@ export function _getPackageInfo( ); if (packageJsonExportsEntry) { - secondaryEntryPoint = packageJsonExportsEntry; + secondaryEntryPoint = mainPkgJson?.exports?.[packageJsonExportsEntry]; - if (secondaryEntryPoint.endsWith('*')) { + if (packageJsonExportsEntry.endsWith('*')) { const replacement = relSecondaryPath.substring( packageJsonExportsEntry.length - 1, ); - secondaryEntryPoint = replaceGlob( - mainPkgJson?.exports?.[packageJsonExportsEntry], - replacement, - ); + secondaryEntryPoint = replaceGlob(secondaryEntryPoint, replacement); } } From d76b213e17f4c13a579915a69de3fb181f5555e3 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 10:13:12 +0100 Subject: [PATCH 07/16] fix(native-federation): Allows to opt-out of removeUnusedDeps --- libs/mf/README.md | 14 ++++++++++++++ .../src/lib/config/share-utils.ts | 1 + .../src/lib/core/remove-unused-deps.ts | 15 ++++++--------- 3 files changed, 21 insertions(+), 9 deletions(-) diff --git a/libs/mf/README.md b/libs/mf/README.md index 1096ecb3..b5af1677 100644 --- a/libs/mf/README.md +++ b/libs/mf/README.md @@ -360,6 +360,20 @@ shared: share({ }) ``` +Finally, it's also possible to break out of the "removeUnusedDep" for a specific external if desired, for example when sharing a whole suite of external modules. This can be handy when you want to avoid the chance of cross-version secondary entrypoints being used by the different micro frontends. E.g. mfe1 uses @angular/core v20.1.0 and mfe2 uses @angular/core/rxjs-interop v20.0.8, then you might want to use consistent use of v20.1.0 so rxjs-interop should be exported by mfe1. The "shareAll" prop allows you to enforce this: + +```typescript +shared: share({ + "@angular/core": { + singleton: true, + strictVersion: true, + requiredVersion: "auto", + includeSecondaries: {shareAll: true} + }, + [...] +}) +``` + #### shareAll The `shareAll` helper shares all your dependencies defined in your `package.json`. The `package.json` is look up as described above: diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index 8b63cad7..aae61af5 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -579,6 +579,7 @@ export function share( if (shareObject.includeSecondaries) { includeSecondaries = shareObject.includeSecondaries; delete shareObject.includeSecondaries; + if (!!includeSecondaries?.shareAll) shareObject.includeSecondaries = true; } result[key] = shareObject; diff --git a/libs/native-federation-core/src/lib/core/remove-unused-deps.ts b/libs/native-federation-core/src/lib/core/remove-unused-deps.ts index ec819acb..88c6f24e 100644 --- a/libs/native-federation-core/src/lib/core/remove-unused-deps.ts +++ b/libs/native-federation-core/src/lib/core/remove-unused-deps.ts @@ -38,15 +38,12 @@ function filterShared( config: NormalizedFederationConfig, usedPackageNamesWithTransient: Set, ) { - const filteredSharedNames = Object.keys(config.shared).filter((shared) => - usedPackageNamesWithTransient.has(shared), - ); - - const filteredShared = filteredSharedNames.reduce( - (acc, curr) => ({ ...acc, [curr]: config.shared[curr] }), - {}, - ); - return filteredShared; + return Object.entries(config.shared) + .filter( + ([shared, meta]) => + !!meta.includeSecondaries || usedPackageNamesWithTransient.has(shared), + ) + .reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {}); } function findUsedDeps( From 3b5002ac3e6392fda58269b7afb70970761e24cd Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 10:17:49 +0100 Subject: [PATCH 08/16] chore: Removed redundant double-negations --- libs/native-federation-core/src/lib/config/share-utils.ts | 2 +- libs/native-federation-core/src/lib/utils/package-info.ts | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index aae61af5..eea31a44 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -579,7 +579,7 @@ export function share( if (shareObject.includeSecondaries) { includeSecondaries = shareObject.includeSecondaries; delete shareObject.includeSecondaries; - if (!!includeSecondaries?.shareAll) shareObject.includeSecondaries = true; + if (includeSecondaries?.shareAll) shareObject.includeSecondaries = true; } result[key] = shareObject; diff --git a/libs/native-federation-core/src/lib/utils/package-info.ts b/libs/native-federation-core/src/lib/utils/package-info.ts index 2192d001..3caf34cc 100644 --- a/libs/native-federation-core/src/lib/utils/package-info.ts +++ b/libs/native-federation-core/src/lib/utils/package-info.ts @@ -280,14 +280,14 @@ export function _getPackageInfo( } } - if (!!secondaryEntryPoint) { + if (secondaryEntryPoint) { const info = findOptimalExport(secondaryEntryPoint, { entryPoint: mainPkgPath, packageName, version, esm, }); - if (!!info) return info; + if (info) return info; } if (mainPkgJson['module'] && relSecondaryPath === '.') { From 3f0836f6eb8813919df7f654bb929ddb89e116dc Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Fri, 12 Dec 2025 17:08:03 +0100 Subject: [PATCH 09/16] fix(native-federation): Stable isESM check --- .../src/lib/utils/package-info.ts | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/libs/native-federation-core/src/lib/utils/package-info.ts b/libs/native-federation-core/src/lib/utils/package-info.ts index 3caf34cc..01c68251 100644 --- a/libs/native-federation-core/src/lib/utils/package-info.ts +++ b/libs/native-federation-core/src/lib/utils/package-info.ts @@ -34,11 +34,17 @@ export type ExportCondition = | (string & {}); export const isESMExport = (e: string): boolean | undefined => { - if (e === 'node' || e === 'import' || e.startsWith('es')) return true; - if (e === 'require' || e === 'cjs') return false; + if (e === 'import' || e === 'module-sync') return true; + // Common ESM conventions + if (e === 'module' || e === 'esm' || /^es20\d{2}$/.test(e)) return true; + + if (e === 'require') return false; + // Common CJS conventions + if (e === 'cjs' || e === 'commonjs') return false; + + // Ambiguous return undefined; }; - export type ExportEntry = | string | undefined From 270e273c7bd05f40d5a755b983477353051861e0 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 09:01:27 +0100 Subject: [PATCH 10/16] fix(native-federation): Switched to per-package bundles --- .../src/lib/core/build-for-federation.ts | 124 ++++++------------ .../src/lib/core/bundle-shared.ts | 6 +- 2 files changed, 48 insertions(+), 82 deletions(-) diff --git a/libs/native-federation-core/src/lib/core/build-for-federation.ts b/libs/native-federation-core/src/lib/core/build-for-federation.ts index 17a2db4a..56b68f5f 100644 --- a/libs/native-federation-core/src/lib/core/build-for-federation.ts +++ b/libs/native-federation-core/src/lib/core/build-for-federation.ts @@ -83,57 +83,12 @@ export async function buildForFederation( } if (!buildParams.skipShared && sharedPackageInfoCache.length === 0) { - const { sharedBrowser, sharedServer, separateBrowser, separateServer } = - splitShared(config.shared); + const { sharedBrowser, sharedServer } = splitShared(config.shared); if (Object.keys(sharedBrowser).length > 0) { const start = process.hrtime(); - const sharedPackageInfoBrowser = await bundleShared( + const separatePackageInfoBrowser = await bundlePerPackage( sharedBrowser, - config, - fedOptions, - externals, - 'browser', - { pathToCache, bundleName: 'browser-shared' }, - ); - - logger.measure( - start, - '[build artifacts] - To bundle all shared browser externals', - ); - - sharedPackageInfoCache.push(...sharedPackageInfoBrowser); - - if (signal?.aborted) - throw new AbortedError( - '[buildForFederation] After shared-browser bundle', - ); - } - - if (Object.keys(sharedServer).length > 0) { - const start = process.hrtime(); - const sharedPackageInfoServer = await bundleShared( - sharedServer, - config, - fedOptions, - externals, - 'node', - { pathToCache, bundleName: 'node-shared' }, - ); - logger.measure( - start, - '[build artifacts] - To bundle all shared node externals', - ); - sharedPackageInfoCache.push(...sharedPackageInfoServer); - - if (signal?.aborted) - throw new AbortedError('[buildForFederation] After shared-node bundle'); - } - - if (Object.keys(separateBrowser).length > 0) { - const start = process.hrtime(); - const separatePackageInfoBrowser = await bundleSeparate( - separateBrowser, externals, config, fedOptions, @@ -142,35 +97,30 @@ export async function buildForFederation( ); logger.measure( start, - '[build artifacts] - To bundle all separate browser externals', + '[build artifacts] - To bundle all browser externals', ); sharedPackageInfoCache.push(...separatePackageInfoBrowser); if (signal?.aborted) - throw new AbortedError( - '[buildForFederation] After separate-browser bundle', - ); + throw new AbortedError('[buildForFederation] After browser bundle'); } - if (Object.keys(separateServer).length > 0) { + if (Object.keys(sharedServer).length > 0) { const start = process.hrtime(); - const separatePackageInfoServer = await bundleSeparate( - separateServer, + const separatePackageInfoServer = await bundlePerPackage( + sharedServer, externals, config, fedOptions, 'node', pathToCache, ); - logger.measure( - start, - '[build artifacts] - To bundle all separate node externals', - ); + logger.measure(start, '[build artifacts] - To bundle all node externals'); sharedPackageInfoCache.push(...separatePackageInfoServer); } if (signal?.aborted) - throw new AbortedError('[buildForFederation] After separate-node bundle'); + throw new AbortedError('[buildForFederation] After node bundle'); } const sharedMappingInfo = !artefactInfo @@ -198,8 +148,6 @@ export async function buildForFederation( type SplitSharedResult = { sharedServer: Record; sharedBrowser: Record; - separateBrowser: Record; - separateServer: Record; }; function inferPackageFromSecondary(secondary: string): string { @@ -210,7 +158,7 @@ function inferPackageFromSecondary(secondary: string): string { return parts[0]; } -async function bundleSeparate( +async function bundlePerPackage( separateBrowser: Record, externals: string[], config: NormalizedFederationConfig, @@ -218,21 +166,30 @@ async function bundleSeparate( platform: 'node' | 'browser', pathToCache: string, ) { - const bundlePromises = Object.entries(separateBrowser).map( - async ([key, shared]) => { - const packageName = inferPackageFromSecondary(key); - const filteredExternals = externals.filter( - (e) => !e.startsWith(packageName), - ); + const groupedByPackage: Record< + string, + Record + > = {}; + + for (const [key, shared] of Object.entries(separateBrowser)) { + const packageName = inferPackageFromSecondary(key); + if (!groupedByPackage[packageName]) { + groupedByPackage[packageName] = {}; + } + groupedByPackage[packageName][key] = shared; + } + + const bundlePromises = Object.entries(groupedByPackage).map( + async ([packageName, sharedGroup]) => { return bundleShared( - { [key]: shared }, + sharedGroup, config, fedOptions, - filteredExternals, + externals, platform, { pathToCache, - bundleName: `${platform}-${normalizePackageName(key)}`, + bundleName: `${platform}-${normalizePackageName(packageName)}`, }, ); }, @@ -247,26 +204,31 @@ function splitShared( ): SplitSharedResult { const sharedServer: Record = {}; const sharedBrowser: Record = {}; - const separateBrowser: Record = {}; - const separateServer: Record = {}; + // const separateBrowser: Record = {}; + // const separateServer: Record = {}; for (const key in shared) { const obj = shared[key]; - if (obj.platform === 'node' && obj.build === 'default') { + if (obj.platform === 'node') { sharedServer[key] = obj; - } else if (obj.platform === 'node' && obj.build === 'separate') { - separateServer[key] = obj; - } else if (obj.platform === 'browser' && obj.build === 'default') { - sharedBrowser[key] = obj; } else { - separateBrowser[key] = obj; + sharedBrowser[key] = obj; } + // if (obj.platform === 'node' && obj.build === 'default') { + // sharedServer[key] = obj; + // } else if (obj.platform === 'node' && obj.build === 'separate') { + // separateServer[key] = obj; + // } else if (obj.platform === 'browser' && obj.build === 'default') { + // sharedBrowser[key] = obj; + // } else { + // separateBrowser[key] = obj; + // } } return { sharedBrowser, sharedServer, - separateBrowser, - separateServer, + // separateBrowser, + // separateServer, }; } diff --git a/libs/native-federation-core/src/lib/core/bundle-shared.ts b/libs/native-federation-core/src/lib/core/bundle-shared.ts index b59911a0..8bf6a330 100644 --- a/libs/native-federation-core/src/lib/core/bundle-shared.ts +++ b/libs/native-federation-core/src/lib/core/bundle-shared.ts @@ -111,12 +111,16 @@ export async function bundleShared( : []; let bundleResult: BuildResult[] | null = null; + const internalEntryPoints = new Set(packageInfos.map((e) => e.packageName)); try { bundleResult = await bundle({ entryPoints, tsConfigPath: fedOptions.tsConfig, - external: [...additionalExternals, ...externals], + external: [ + ...additionalExternals, + ...externals.filter((e) => !internalEntryPoints.has(e)), + ], outdir: cacheOptions.pathToCache, mappedPaths: config.sharedMappings, dev: fedOptions.dev, From 1f250591407deb745bcaaacfc53e92cf1885a879 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 09:23:42 +0100 Subject: [PATCH 11/16] fix(native-federation): Allow for agressive wildcard filter with secondary entryPoints --- .../src/lib/config/share-utils.ts | 16 +++++++++----- .../src/lib/core/bundle-shared.ts | 3 +-- .../src/lib/init-federation.ts | 22 +++++++++---------- 3 files changed, 22 insertions(+), 19 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index eea31a44..c8afc35a 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -126,8 +126,11 @@ function _findSecondaries( const secondaryLibName = s .replace(/\\/g, '/') .replace(/^.*node_modules[/]/, ''); - if (excludes.includes(secondaryLibName)) { - continue; + + for (const e in excludes) { + if (e === secondaryLibName) continue; + if (e.endsWith('*') && secondaryLibName.startsWith(e.slice(0, -1))) + continue; } if (isInSkipList(secondaryLibName, preparedSkipList)) { @@ -243,8 +246,9 @@ function readConfiguredSecondaries( for (const key of keys) { const secondaryName = path.join(parent, key).replace(/\\/g, '/'); - if (exclude.includes(secondaryName)) { - continue; + for (const e in exclude) { + if (e === secondaryName) continue; + if (e.endsWith('*') && secondaryName.startsWith(e.slice(0, -1))) continue; } if (isInSkipList(secondaryName, preparedSkipList)) { @@ -266,7 +270,7 @@ function readConfiguredSecondaries( continue; } - const items = resolveSecondaries( + const items = resolveGlobSecondaries( key, libPath, parent, @@ -300,7 +304,7 @@ function readConfiguredSecondaries( return result; } -function resolveSecondaries( +function resolveGlobSecondaries( key: string, libPath: string, parent: string, diff --git a/libs/native-federation-core/src/lib/core/bundle-shared.ts b/libs/native-federation-core/src/lib/core/bundle-shared.ts index 8bf6a330..4898fb55 100644 --- a/libs/native-federation-core/src/lib/core/bundle-shared.ts +++ b/libs/native-federation-core/src/lib/core/bundle-shared.ts @@ -248,7 +248,7 @@ function addChunksToResult( for (const item of chunks) { const fileName = path.basename(item.fileName); result.push({ - singleton: false, + singleton: true, strictVersion: false, // Here, the version does not matter because // a) a chunk split off by the bundler does @@ -259,7 +259,6 @@ function addChunksToResult( // For the same reason, we don't need to // take care of singleton and strictVersion. requiredVersion: '0.0.0', - version: '0.0.0', packageName: deriveInternalName(fileName), outFileName: fileName, // dev: dev diff --git a/libs/native-federation-runtime/src/lib/init-federation.ts b/libs/native-federation-runtime/src/lib/init-federation.ts index ecad2982..cc5d4b7c 100644 --- a/libs/native-federation-runtime/src/lib/init-federation.ts +++ b/libs/native-federation-runtime/src/lib/init-federation.ts @@ -22,7 +22,7 @@ import { watchFederationBuildCompletion } from './watch-federation-build'; */ export async function initFederation( remotesOrManifestUrl: Record | string = {}, - options?: InitFederationOptions + options?: InitFederationOptions, ): Promise { const cacheOption = options?.cacheTag ? `?t=${options.cacheTag}` : ''; const remotes = @@ -50,7 +50,7 @@ async function loadManifest(remotes: string): Promise> { export async function processRemoteInfos( remotes: Record, - options: ProcessRemoteInfoOptions = { throwIfRemoteNotFound: false } + options: ProcessRemoteInfoOptions = { throwIfRemoteNotFound: false }, ): Promise { const processRemoteInfoPromises = Object.keys(remotes).map( async (remoteName) => { @@ -72,7 +72,7 @@ export async function processRemoteInfos( console.error(error); return null; } - } + }, ); const remoteImportMaps = await Promise.all(processRemoteInfoPromises); @@ -80,7 +80,7 @@ export async function processRemoteInfos( const importMap = remoteImportMaps.reduce( (acc, remoteImportMap) => remoteImportMap ? mergeImportMaps(acc, remoteImportMap) : acc, - { imports: {}, scopes: {} } + { imports: {}, scopes: {} }, ); return importMap; @@ -88,7 +88,7 @@ export async function processRemoteInfos( export async function processRemoteInfo( federationInfoUrl: string, - remoteName?: string + remoteName?: string, ): Promise { const baseUrl = getDirectory(federationInfoUrl); const remoteInfo = await loadFederationInfo(federationInfoUrl); @@ -99,7 +99,7 @@ export async function processRemoteInfo( if (remoteInfo.buildNotificationsEndpoint) { watchFederationBuildCompletion( - baseUrl + remoteInfo.buildNotificationsEndpoint + baseUrl + remoteInfo.buildNotificationsEndpoint, ); } @@ -112,7 +112,7 @@ export async function processRemoteInfo( function createRemoteImportMap( remoteInfo: FederationInfo, remoteName: string, - baseUrl: string + baseUrl: string, ): ImportMap { const imports = processExposed(remoteInfo, remoteName, baseUrl); const scopes = processRemoteImports(remoteInfo, baseUrl); @@ -126,7 +126,7 @@ async function loadFederationInfo(url: string): Promise { function processRemoteImports( remoteInfo: FederationInfo, - baseUrl: string + baseUrl: string, ): Scopes { const scopes: Scopes = {}; const scopedImports: Imports = {}; @@ -145,7 +145,7 @@ function processRemoteImports( function processExposed( remoteInfo: FederationInfo, remoteName: string, - baseUrl: string + baseUrl: string, ): Imports { const imports: Imports = {}; @@ -160,14 +160,14 @@ function processExposed( export async function processHostInfo( hostInfo: FederationInfo, - relBundlesPath = './' + relBundlesPath = './', ): Promise { const imports = hostInfo.shared.reduce( (acc, cur) => ({ ...acc, [cur.packageName]: relBundlesPath + cur.outFileName, }), - {} + {}, ) as Imports; for (const shared of hostInfo.shared) { From a003d4e10fd7a066e4ff4703af76d5571f195aa4 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 10:47:01 +0100 Subject: [PATCH 12/16] fix(native-federation): Fix sharing issues --- .../src/lib/config/share-utils.ts | 21 +++++++++++-------- .../src/lib/core/build-for-federation.ts | 6 ++++++ .../src/lib/core/bundle-shared.ts | 8 ------- .../src/lib/utils/bundle-caching.ts | 9 +++----- 4 files changed, 21 insertions(+), 23 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index c8afc35a..5a56d073 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -127,11 +127,12 @@ function _findSecondaries( .replace(/\\/g, '/') .replace(/^.*node_modules[/]/, ''); - for (const e in excludes) { - if (e === secondaryLibName) continue; - if (e.endsWith('*') && secondaryLibName.startsWith(e.slice(0, -1))) - continue; - } + let inCustomSkipList = excludes.some( + (e) => + e === secondaryLibName || + (e.endsWith('*') && secondaryLibName.startsWith(e.slice(0, -1))), + ); + if (inCustomSkipList) continue; if (isInSkipList(secondaryLibName, preparedSkipList)) { continue; @@ -246,10 +247,12 @@ function readConfiguredSecondaries( for (const key of keys) { const secondaryName = path.join(parent, key).replace(/\\/g, '/'); - for (const e in exclude) { - if (e === secondaryName) continue; - if (e.endsWith('*') && secondaryName.startsWith(e.slice(0, -1))) continue; - } + let inCustomSkipList = exclude.some( + (e) => + e === secondaryName || + (e.endsWith('*') && secondaryName.startsWith(e.slice(0, -1))), + ); + if (inCustomSkipList) continue; if (isInSkipList(secondaryName, preparedSkipList)) { continue; diff --git a/libs/native-federation-core/src/lib/core/build-for-federation.ts b/libs/native-federation-core/src/lib/core/build-for-federation.ts index 56b68f5f..44d74226 100644 --- a/libs/native-federation-core/src/lib/core/build-for-federation.ts +++ b/libs/native-federation-core/src/lib/core/build-for-federation.ts @@ -179,6 +179,12 @@ async function bundlePerPackage( groupedByPackage[packageName][key] = shared; } + logger.info('Preparing shared npm packages for the platform ' + platform); + logger.notice('This only needs to be done once, as results are cached'); + logger.notice( + "Skip packages you don't want to share in your federation config", + ); + const bundlePromises = Object.entries(groupedByPackage).map( async ([packageName, sharedGroup]) => { return bundleShared( diff --git a/libs/native-federation-core/src/lib/core/bundle-shared.ts b/libs/native-federation-core/src/lib/core/bundle-shared.ts index 4898fb55..df669746 100644 --- a/libs/native-federation-core/src/lib/core/bundle-shared.ts +++ b/libs/native-federation-core/src/lib/core/bundle-shared.ts @@ -93,14 +93,6 @@ export async function bundleShared( (ep) => !fs.existsSync(path.join(cacheOptions.pathToCache, ep.outName)), ); - if (entryPoints.length > 0) { - logger.info('Preparing shared npm packages for the platform ' + platform); - logger.notice('This only needs to be done once, as results are cached'); - logger.notice( - "Skip packages you don't want to share in your federation config", - ); - } - // If we build for the browser and don't remote unused deps from the shared config, // we need to exclude typical node libs to avoid compilation issues const useDefaultExternalList = diff --git a/libs/native-federation-core/src/lib/utils/bundle-caching.ts b/libs/native-federation-core/src/lib/utils/bundle-caching.ts index 7c94b8ff..514b3e50 100644 --- a/libs/native-federation-core/src/lib/utils/bundle-caching.ts +++ b/libs/native-federation-core/src/lib/utils/bundle-caching.ts @@ -96,12 +96,9 @@ export const cacheEntry = (pathToCache: string, fileName: string) => ({ logger.debug(`Creating cache folder '${pathToCache}' for '${fileName}'.`); return; } - if (!fs.existsSync(metadataFile)) { - logger.debug( - `Could not purge cached bundle, metadata file '${metadataFile}' does not exist.`, - ); - return; - } + if (!fs.existsSync(metadataFile)) return; + + logger.debug(`Purging cached bundle '${metadataFile}'.`); const cachedResult: { checksum: string; From 2e256a2a5b508ce5d6f763927b28df8cbd02af88 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 11:27:07 +0100 Subject: [PATCH 13/16] fix: Added overrides option to shareAll --- .../src/lib/config/share-utils.ts | 41 ++++++++++++++----- 1 file changed, 31 insertions(+), 10 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index 5a56d073..5e50d415 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -379,12 +379,14 @@ function getDefaultEntry( export function shareAll( config: CustomSharedConfig = {}, - skip: SkipList = DEFAULT_SKIP_LIST, - projectPath = '', + opts: { + skipList?: SkipList; + projectPath?: string; + overrides?: Config; + } = {}, ): Config | null { // let workspacePath: string | undefined = undefined; - - projectPath = inferProjectPath(projectPath); + const projectPath = inferProjectPath(opts.projectPath); // workspacePath = getConfigContext().workspaceRoot ?? ''; @@ -393,14 +395,20 @@ export function shareAll( // } const versionMaps = getVersionMaps(projectPath, projectPath); - const share: Record = {}; - const preparedSkipList = prepareSkipList(skip); + const sharedExternals: Config = {}; + const preparedSkipList = prepareSkipList(opts.skipList ?? DEFAULT_SKIP_LIST); for (const versions of versionMaps) { for (const key in versions) { if (isInSkipList(key, preparedSkipList)) { continue; } + if ( + !!opts.overrides && + Object.keys(opts.overrides).some((o) => key.startsWith(o)) + ) { + continue; + } const inferVersion = !config.requiredVersion || config.requiredVersion === 'auto'; @@ -408,16 +416,29 @@ export function shareAll( ? versions[key] : config.requiredVersion; - if (!share[key]) { - share[key] = { ...config, requiredVersion }; + if (!sharedExternals[key]) { + sharedExternals[key] = { ...config, requiredVersion }; } } } - return module.exports.share(share, projectPath, skip); + return { + ...share( + sharedExternals, + opts.projectPath, + opts.skipList ?? DEFAULT_SKIP_LIST, + ), + ...(!opts.overrides + ? {} + : share( + opts.overrides, + opts.projectPath, + opts.skipList ?? DEFAULT_SKIP_LIST, + )), + }; } -function inferProjectPath(projectPath: string) { +function inferProjectPath(projectPath: string | undefined) { if (!projectPath && getConfigContext().packageJson) { projectPath = path.dirname(getConfigContext().packageJson || ''); } From 026f08f45af45138740fcb1eda1879d7f83db1a3 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 12:54:38 +0100 Subject: [PATCH 14/16] fix(native-federation): Re-enabled shared bundles --- .../src/lib/core/build-for-federation.ts | 117 +++++++++++++----- .../src/lib/core/bundle-shared.ts | 6 +- 2 files changed, 86 insertions(+), 37 deletions(-) diff --git a/libs/native-federation-core/src/lib/core/build-for-federation.ts b/libs/native-federation-core/src/lib/core/build-for-federation.ts index 44d74226..1a656044 100644 --- a/libs/native-federation-core/src/lib/core/build-for-federation.ts +++ b/libs/native-federation-core/src/lib/core/build-for-federation.ts @@ -83,12 +83,60 @@ export async function buildForFederation( } if (!buildParams.skipShared && sharedPackageInfoCache.length === 0) { - const { sharedBrowser, sharedServer } = splitShared(config.shared); + const { sharedBrowser, sharedServer, separateBrowser, separateServer } = + splitShared(config.shared); if (Object.keys(sharedBrowser).length > 0) { + notifyBundling('browser-shared'); const start = process.hrtime(); - const separatePackageInfoBrowser = await bundlePerPackage( + const sharedPackageInfoBrowser = await bundleShared( sharedBrowser, + config, + fedOptions, + externals, + 'browser', + { pathToCache, bundleName: 'browser-shared' }, + ); + + logger.measure( + start, + '[build artifacts] - To bundle all shared browser externals', + ); + + sharedPackageInfoCache.push(...sharedPackageInfoBrowser); + + if (signal?.aborted) + throw new AbortedError( + '[buildForFederation] After shared-browser bundle', + ); + } + + if (Object.keys(sharedServer).length > 0) { + notifyBundling('browser-shared'); + const start = process.hrtime(); + const sharedPackageInfoServer = await bundleShared( + sharedServer, + config, + fedOptions, + externals, + 'node', + { pathToCache, bundleName: 'node-shared' }, + ); + logger.measure( + start, + '[build artifacts] - To bundle all shared node externals', + ); + sharedPackageInfoCache.push(...sharedPackageInfoServer); + + if (signal?.aborted) + throw new AbortedError('[buildForFederation] After shared-node bundle'); + } + + if (Object.keys(separateBrowser).length > 0) { + notifyBundling('browser-shared'); + const start = process.hrtime(); + const separatePackageInfoBrowser = await bundleSeparatePackages( + separateBrowser, externals, config, fedOptions, @@ -97,30 +145,36 @@ export async function buildForFederation( ); logger.measure( start, - '[build artifacts] - To bundle all browser externals', + '[build artifacts] - To bundle all separate browser externals', ); sharedPackageInfoCache.push(...separatePackageInfoBrowser); if (signal?.aborted) - throw new AbortedError('[buildForFederation] After browser bundle'); + throw new AbortedError( + '[buildForFederation] After separate-browser bundle', + ); } - if (Object.keys(sharedServer).length > 0) { + if (Object.keys(separateServer).length > 0) { + notifyBundling('browser-shared'); const start = process.hrtime(); - const separatePackageInfoServer = await bundlePerPackage( - sharedServer, + const separatePackageInfoServer = await bundleSeparatePackages( + separateServer, externals, config, fedOptions, 'node', pathToCache, ); - logger.measure(start, '[build artifacts] - To bundle all node externals'); + logger.measure( + start, + '[build artifacts] - To bundle all separate node externals', + ); sharedPackageInfoCache.push(...separatePackageInfoServer); } if (signal?.aborted) - throw new AbortedError('[buildForFederation] After node bundle'); + throw new AbortedError('[buildForFederation] After separate-node bundle'); } const sharedMappingInfo = !artefactInfo @@ -148,6 +202,8 @@ export async function buildForFederation( type SplitSharedResult = { sharedServer: Record; sharedBrowser: Record; + separateBrowser: Record; + separateServer: Record; }; function inferPackageFromSecondary(secondary: string): string { @@ -158,7 +214,7 @@ function inferPackageFromSecondary(secondary: string): string { return parts[0]; } -async function bundlePerPackage( +async function bundleSeparatePackages( separateBrowser: Record, externals: string[], config: NormalizedFederationConfig, @@ -179,19 +235,13 @@ async function bundlePerPackage( groupedByPackage[packageName][key] = shared; } - logger.info('Preparing shared npm packages for the platform ' + platform); - logger.notice('This only needs to be done once, as results are cached'); - logger.notice( - "Skip packages you don't want to share in your federation config", - ); - const bundlePromises = Object.entries(groupedByPackage).map( async ([packageName, sharedGroup]) => { return bundleShared( sharedGroup, config, fedOptions, - externals, + externals.filter((e) => !e.startsWith(packageName)), platform, { pathToCache, @@ -205,36 +255,39 @@ async function bundlePerPackage( return buildResults.flat(); } +function notifyBundling(platform: string) { + logger.info('Preparing shared npm packages for the platform ' + platform); + logger.notice('This only needs to be done once, as results are cached'); + logger.notice( + "Skip packages you don't want to share in your federation config", + ); +} + function splitShared( shared: Record, ): SplitSharedResult { const sharedServer: Record = {}; const sharedBrowser: Record = {}; - // const separateBrowser: Record = {}; - // const separateServer: Record = {}; + const separateBrowser: Record = {}; + const separateServer: Record = {}; for (const key in shared) { const obj = shared[key]; - if (obj.platform === 'node') { + if (obj.platform === 'node' && obj.build === 'default') { sharedServer[key] = obj; - } else { + } else if (obj.platform === 'node' && obj.build === 'separate') { + separateServer[key] = obj; + } else if (obj.platform === 'browser' && obj.build === 'default') { sharedBrowser[key] = obj; + } else { + separateBrowser[key] = obj; } - // if (obj.platform === 'node' && obj.build === 'default') { - // sharedServer[key] = obj; - // } else if (obj.platform === 'node' && obj.build === 'separate') { - // separateServer[key] = obj; - // } else if (obj.platform === 'browser' && obj.build === 'default') { - // sharedBrowser[key] = obj; - // } else { - // separateBrowser[key] = obj; - // } } return { sharedBrowser, sharedServer, - // separateBrowser, - // separateServer, + separateBrowser, + separateServer, }; } diff --git a/libs/native-federation-core/src/lib/core/bundle-shared.ts b/libs/native-federation-core/src/lib/core/bundle-shared.ts index df669746..0d18b721 100644 --- a/libs/native-federation-core/src/lib/core/bundle-shared.ts +++ b/libs/native-federation-core/src/lib/core/bundle-shared.ts @@ -103,16 +103,12 @@ export async function bundleShared( : []; let bundleResult: BuildResult[] | null = null; - const internalEntryPoints = new Set(packageInfos.map((e) => e.packageName)); try { bundleResult = await bundle({ entryPoints, tsConfigPath: fedOptions.tsConfig, - external: [ - ...additionalExternals, - ...externals.filter((e) => !internalEntryPoints.has(e)), - ], + external: [...additionalExternals, ...externals], outdir: cacheOptions.pathToCache, mappedPaths: config.sharedMappings, dev: fedOptions.dev, From 75679a76f2c979a8592682311ab2a2319ac5d79d Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 13:10:39 +0100 Subject: [PATCH 15/16] fix: linting errors --- libs/native-federation-core/src/lib/config/share-utils.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/share-utils.ts b/libs/native-federation-core/src/lib/config/share-utils.ts index 5e50d415..1027ba9f 100644 --- a/libs/native-federation-core/src/lib/config/share-utils.ts +++ b/libs/native-federation-core/src/lib/config/share-utils.ts @@ -127,7 +127,7 @@ function _findSecondaries( .replace(/\\/g, '/') .replace(/^.*node_modules[/]/, ''); - let inCustomSkipList = excludes.some( + const inCustomSkipList = excludes.some( (e) => e === secondaryLibName || (e.endsWith('*') && secondaryLibName.startsWith(e.slice(0, -1))), @@ -247,7 +247,7 @@ function readConfiguredSecondaries( for (const key of keys) { const secondaryName = path.join(parent, key).replace(/\\/g, '/'); - let inCustomSkipList = exclude.some( + const inCustomSkipList = exclude.some( (e) => e === secondaryName || (e.endsWith('*') && secondaryName.startsWith(e.slice(0, -1))), From e6f1056a310cfcf79e2ad25b0a2762ad26f7cc21 Mon Sep 17 00:00:00 2001 From: Aukevanoost Date: Mon, 15 Dec 2025 17:10:55 +0100 Subject: [PATCH 16/16] fix: Added choice between package level isolation or separate secondary-entry-points --- .../src/lib/config/federation-config.ts | 2 +- .../src/lib/core/build-for-federation.ts | 24 ++++++++++++------- 2 files changed, 16 insertions(+), 10 deletions(-) diff --git a/libs/native-federation-core/src/lib/config/federation-config.ts b/libs/native-federation-core/src/lib/config/federation-config.ts index 8d61d748..763c5e8d 100644 --- a/libs/native-federation-core/src/lib/config/federation-config.ts +++ b/libs/native-federation-core/src/lib/config/federation-config.ts @@ -37,7 +37,7 @@ export interface NormalizedSharedConfig { version?: string; includeSecondaries?: boolean; platform: 'browser' | 'node'; - build: 'default' | 'separate'; + build: 'default' | 'separate' | 'package'; packageInfo?: { entryPoint: string; version: string; diff --git a/libs/native-federation-core/src/lib/core/build-for-federation.ts b/libs/native-federation-core/src/lib/core/build-for-federation.ts index 1a656044..adfb8be5 100644 --- a/libs/native-federation-core/src/lib/core/build-for-federation.ts +++ b/libs/native-federation-core/src/lib/core/build-for-federation.ts @@ -228,7 +228,8 @@ async function bundleSeparatePackages( > = {}; for (const [key, shared] of Object.entries(separateBrowser)) { - const packageName = inferPackageFromSecondary(key); + const packageName = + shared.build === 'separate' ? key : inferPackageFromSecondary(key); if (!groupedByPackage[packageName]) { groupedByPackage[packageName] = {}; } @@ -273,14 +274,19 @@ function splitShared( for (const key in shared) { const obj = shared[key]; - if (obj.platform === 'node' && obj.build === 'default') { - sharedServer[key] = obj; - } else if (obj.platform === 'node' && obj.build === 'separate') { - separateServer[key] = obj; - } else if (obj.platform === 'browser' && obj.build === 'default') { - sharedBrowser[key] = obj; - } else { - separateBrowser[key] = obj; + + if (obj.platform === 'node') { + if (obj.build === 'default') { + sharedServer[key] = obj; + } else { + separateServer[key] = obj; + } + } else if (obj.platform === 'browser') { + if (obj.build === 'default') { + sharedBrowser[key] = obj; + } else { + separateBrowser[key] = obj; + } } }