@softarc/native-federation 4.0.0-RC7 → 4.0.0-RC9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softarc/native-federation",
-  "version": "4.0.0-RC7",
+  "version": "4.0.0-RC9",
   "type": "module",
   "license": "MIT",
   "dependencies": {

package/src/index.d.ts

@@ -1,11 +1,10 @@
 export { setBuildAdapter } from './lib/core/build-adapter.js';
 export { buildForFederation } from './lib/core/build-for-federation.js';
 export { rebuildForFederation } from './lib/core/rebuild-for-federation.js';
-export { normalizeFederationOptions } from './lib/core/normalize-federation-options.js';
 export { createFederationCache } from './lib/core/federation-cache.js';
 export { bundleExposedAndMappings } from './lib/core/bundle-exposed-and-mappings.js';
 export { getExternals } from './lib/core/get-externals.js';
-export { loadFederationConfig } from './lib/core/load-federation-config.js';
+export { normalizeFederationOptions } from './lib/core/normalize-options.js';
 export { writeFederationInfo } from './lib/core/write-federation-info.js';
 export { type BuildHelperParams, federationBuilder } from './lib/core/federation-builder.js';
 export * from './domain.js';

package/src/index.js

@@ -1,11 +1,10 @@
 export { setBuildAdapter } from './lib/core/build-adapter.js';
 export { buildForFederation } from './lib/core/build-for-federation.js';
 export { rebuildForFederation } from './lib/core/rebuild-for-federation.js';
-export { normalizeFederationOptions } from './lib/core/normalize-federation-options.js';
 export { createFederationCache } from './lib/core/federation-cache.js';
 export { bundleExposedAndMappings } from './lib/core/bundle-exposed-and-mappings.js';
 export { getExternals } from './lib/core/get-externals.js';
-export { loadFederationConfig } from './lib/core/load-federation-config.js';
+export { normalizeFederationOptions } from './lib/core/normalize-options.js';
 export { writeFederationInfo } from './lib/core/write-federation-info.js';
 export { federationBuilder } from './lib/core/federation-builder.js';
 export * from './domain.js';

package/src/internal.d.ts

@@ -2,11 +2,12 @@ export * from './lib/utils/build-result-map.js';
 export { hashFile } from './lib/utils/hash-file.js';
 export * from './lib/utils/errors.js';
 export { logger, setLogLevel } from './lib/utils/logger.js';
-export type { MappedPath } from './lib/domain/utils/mapped-path.contract.js';
-export { RebuildQueue } from './lib/utils/rebuild-queue.js';
+export type { PathToImport } from './lib/domain/utils/mapped-path.contract.js';
+export { RebuildQueue, type TrackResult } from './lib/utils/rebuild-queue.js';
 export { AbortedError } from './lib/utils/errors.js';
 export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './lib/utils/build-result-map.js';
 export { writeImportMap } from './lib/core/write-import-map.js';
 export type { NormalizedExternalConfig, NormalizedSharedExternalsConfig, } from './lib/domain/config/external-config.contract.js';
 export type { NormalizedFederationConfig } from './lib/domain/config/federation-config.contract.js';
 export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
+export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';

package/src/internal.js

@@ -7,3 +7,4 @@ export { AbortedError } from './lib/utils/errors.js';
 export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './lib/utils/build-result-map.js';
 export { writeImportMap } from './lib/core/write-import-map.js';
 export { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';
+export { isInSkipList, prepareSkipList } from './lib/config/default-skip-list.js';

package/src/lib/config/default-skip-list.js

@@ -1,26 +1,14 @@
 export const DEFAULT_SKIP_LIST = [
-    '@softarc/native-federation-runtime',
     '@softarc/native-federation',
     '@softarc/native-federation-core',
     '@softarc/native-federation-node',
     '@softarc/native-federation-esbuild',
-    '@angular-architects/native-federation',
-    '@angular-architects/native-federation-runtime',
+    '@softarc/native-federation-runtime',
+    '@softarc/native-federation-orchestrator',
+    'vanilla-native-federation',
     'es-module-shims',
-    'zone.js',
     'tslib/',
-    '@angular/localize',
-    '@angular/localize/init',
-    '@angular/localize/tools',
-    // '@angular/platform-server',
-    // '@angular/platform-server/init',
-    // '@angular/ssr',
-    /\/schematics(\/|$)/,
-    /^@nx\/angular/,
-    pkg => pkg.startsWith('@angular/') && !!pkg.match(/\/testing(\/|$)/),
     pkg => pkg.startsWith('@types/'),
-    'express',
-    // (pkg) => pkg.startsWith('@angular/common/locales'),
 ];
 export function prepareSkipList(skipList) {
     return {

package/src/lib/config/remove-unused-deps.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
+export declare function removeUnusedDeps(usedDependencies: UsedDependencies, config: NormalizedFederationConfig): NormalizedFederationConfig;

package/src/lib/config/remove-unused-deps.js

@@ -0,0 +1,10 @@
+export function removeUnusedDeps(usedDependencies, config) {
+    const filteredDependencies = Object.entries(config.shared)
+        .filter(([shared, meta]) => !!meta.includeSecondaries || usedDependencies.external.has(shared))
+        .reduce((acc, [shared, meta]) => ({ ...acc, [shared]: meta }), {});
+    return {
+        ...config,
+        shared: filteredDependencies,
+        sharedMappings: usedDependencies.internal,
+    };
+}

package/src/lib/config/share-utils.d.ts

@@ -1,6 +1,5 @@
 import { type SkipList } from '../domain/config/skip-list.contract.js';
 import type { ShareAllExternalsOptions, ShareExternalsOptions } from '../domain/config/external-config.contract.js';
-export declare const DEFAULT_SECONDARIES_SKIP_LIST: string[];
 export declare function findRootTsConfigJson(): string;
 export declare function shareAll(config: ShareAllExternalsOptions, opts?: {
     skipList?: SkipList;

package/src/lib/config/share-utils.js

@@ -5,9 +5,8 @@ import { DEFAULT_SKIP_LIST, isInSkipList, prepareSkipList } from './default-skip
 import { findDepPackageJson, getVersionMaps } from '../utils/package-info.js';
 import { getConfigContext } from './configuration-context.js';
 import { logger } from '../utils/logger.js';
-import { resolveWildcardKeys } from '../utils/resolve-wildcard-keys.js';
+import { resolvePackageJsonExportsWildcard } from '../utils/resolve-wildcard-keys.js';
 let inferVersion = false;
-export const DEFAULT_SECONDARIES_SKIP_LIST = ['@angular/router/upgrade', '@angular/common/upgrade'];
 export function findRootTsConfigJson() {
     const packageJson = findPackageJson(cwd());
     const projectRoot = path.dirname(packageJson);
@@ -49,9 +48,6 @@ function lookupVersionInMap(key, versions) {
     else {
         key = parts[0];
     }
-    if (key.toLowerCase() === '@angular-architects/module-federation-runtime') {
-        key = '@angular-architects/module-federation';
-    }
     if (!versions[key]) {
         return null;
     }
@@ -82,7 +78,7 @@ function findSecondaries(libPath, excludes, shareObject, preparedSkipList) {
     return acc;
 }
 function getSecondaries(includeSecondaries, libPath, key, shareObject, preparedSkipList) {
-    let exclude = [...DEFAULT_SECONDARIES_SKIP_LIST];
+    let exclude = [];
     let resolveGlob = false;
     if (typeof includeSecondaries === 'object') {
         if (Array.isArray(includeSecondaries.skip)) {
@@ -166,7 +162,7 @@ function resolveGlobSecondaries(key, libPath, parent, secondaryName, entry, excl
     if (key.includes('*')) {
         if (!resolveGlob)
             return items;
-        const expanded = resolveWildcardKeys(key, entry, libPath);
+        const expanded = resolvePackageJsonExportsWildcard(key, entry, libPath);
         items = expanded
             .map(e => ({
             key: path.join(parent, e.key),
@@ -221,10 +217,10 @@ export function shareAll(config, opts = {}) {
     // }
     const versionMaps = getVersionMaps(projectPath, projectPath);
     const sharedExternals = {};
-    const preparedSkipList = prepareSkipList(opts.skipList ?? DEFAULT_SKIP_LIST);
+    const skipList = opts.skipList ?? DEFAULT_SKIP_LIST;
     for (const versions of versionMaps) {
         for (const key in versions) {
-            if (isInSkipList(key, preparedSkipList)) {
+            if (isInSkipList(key, prepareSkipList(skipList))) {
                 continue;
             }
             if (!!opts.overrides && Object.keys(opts.overrides).some(o => key.startsWith(o))) {
@@ -238,10 +234,8 @@ export function shareAll(config, opts = {}) {
         }
     }
     return {
-        ...share(sharedExternals, opts.projectPath, opts.skipList ?? DEFAULT_SKIP_LIST),
-        ...(!opts.overrides
-            ? {}
-            : share(opts.overrides, opts.projectPath, opts.skipList ?? DEFAULT_SKIP_LIST)),
+        ...share(sharedExternals, opts.projectPath, skipList),
+        ...(!opts.overrides ? {} : share(opts.overrides, opts.projectPath, skipList)),
     };
 }
 function inferProjectPath(projectPath) {

package/src/lib/config/with-native-federation.js

@@ -1,91 +1,70 @@
-import { getMappedPaths } from '../utils/mapped-paths.js';
+import { getRawMappedPaths } from '../utils/mapped-paths.js';
 import { shareAll, findRootTsConfigJson } from './share-utils.js';
 import { isInSkipList, prepareSkipList } from './default-skip-list.js';
 import { logger } from '../utils/logger.js';
-import { DEFAULT_SERVER_DEPS_LIST } from '../core/default-server-deps-list.js';
 export function withNativeFederation(config) {
     const skip = prepareSkipList(config.skip ?? []);
+    const chunks = config.chunks ?? true;
     const normalized = {
+        $type: 'classic',
         name: config.name ?? '',
         exposes: config.exposes ?? {},
-        shared: normalizeShared(config, skip),
-        sharedMappings: normalizeSharedMappings(config, skip),
+        shared: normalizeShared(config, skip, chunks),
+        sharedMappings: removeSkippedMappings(config, skip),
+        chunks,
         skip,
         externals: config.externals ?? [],
         features: {
             mappingVersion: config.features?.mappingVersion ?? false,
-            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? false,
+            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
+            denseChunking: config.features?.denseChunking ?? false,
         },
         ...(config.shareScope && { shareScope: config.shareScope }),
     };
-    // This is for being backwards compatible
-    if (!normalized.features.ignoreUnusedDeps) {
-        normalized.shared = filterShared(normalized.shared);
-    }
     return normalized;
 }
-function filterShared(shared) {
-    const keys = Object.keys(shared).filter(k => !k.startsWith('@angular/common/locales'));
-    const filtered = keys.reduce((acc, curr) => ({
-        ...acc,
-        [curr]: shared[curr],
-    }), {});
-    return filtered;
-}
-function normalizeShared(config, skip) {
+function normalizeShared(config, skip, chunks) {
     let result = {};
-    const shared = config.shared;
-    if (!shared) {
-        result = shareAll({
+    const shared = config.shared ??
+        shareAll({
             singleton: true,
             strictVersion: true,
             requiredVersion: 'auto',
             platform: 'browser',
         });
-    }
-    else {
-        result = Object.keys(shared).reduce((acc, cur) => {
-            const key = cur.replace(/\\/g, '/');
-            const sharedConfig = shared[cur];
-            const normalizedConfig = {
-                requiredVersion: sharedConfig.requiredVersion ?? 'auto',
-                singleton: sharedConfig.singleton ?? false,
-                strictVersion: sharedConfig.strictVersion ?? false,
-                version: sharedConfig.version,
-                includeSecondaries: sharedConfig.includeSecondaries,
-                packageInfo: sharedConfig.packageInfo,
-                platform: sharedConfig.platform ?? getDefaultPlatform(cur),
-                build: sharedConfig.build ?? 'default',
-                ...(sharedConfig.shareScope && { shareScope: sharedConfig.shareScope }),
-            };
-            return {
-                ...acc,
-                [key]: normalizedConfig,
-            };
-        }, {});
-    }
+    result = Object.keys(shared).reduce((acc, cur) => {
+        const key = cur.replace(/\\/g, '/');
+        const sharedConfig = shared[cur];
+        if (!!sharedConfig.chunks && !sharedConfig.build && sharedConfig.chunks !== chunks) {
+            logger.warn(`External '${cur}' has explicit chunk settings, consider switching build type to { build: 'package' }.`);
+            sharedConfig.chunks = chunks;
+        }
+        const normalizedConfig = {
+            requiredVersion: sharedConfig.requiredVersion ?? 'auto',
+            singleton: sharedConfig.singleton ?? false,
+            strictVersion: sharedConfig.strictVersion ?? false,
+            version: sharedConfig.version,
+            chunks: sharedConfig.chunks ?? chunks,
+            includeSecondaries: sharedConfig.includeSecondaries,
+            packageInfo: sharedConfig.packageInfo,
+            platform: sharedConfig.platform ?? config.platform ?? 'browser',
+            build: sharedConfig.build ?? 'default',
+            ...(sharedConfig.shareScope && { shareScope: sharedConfig.shareScope }),
+        };
+        return {
+            ...acc,
+            [key]: normalizedConfig,
+        };
+    }, {});
     result = Object.keys(result)
         .filter(key => !isInSkipList(key, skip))
         .reduce((acc, cur) => ({ ...acc, [cur]: result[cur] }), {});
     return result;
 }
-function normalizeSharedMappings(config, skip) {
+function removeSkippedMappings(config, skipList) {
     const rootTsConfigPath = findRootTsConfigJson();
-    const paths = getMappedPaths({
-        rootTsConfigPath,
-        sharedMappings: config.sharedMappings,
-    });
-    const result = paths.filter(p => !isInSkipList(p.key, skip) && !p.key.includes('*'));
-    if (paths.find(p => p.key.includes('*'))) {
-        logger.warn('Sharing mapped paths with wildcards (*) not supported');
-    }
-    return result;
-}
-function getDefaultPlatform(cur) {
-    if (DEFAULT_SERVER_DEPS_LIST.find(e => cur.startsWith(e))) {
-        return 'node';
-    }
-    else {
-        return 'browser';
-    }
+    const paths = getRawMappedPaths(rootTsConfigPath, config.sharedMappings);
+    return Object.entries(paths)
+        .filter(([, _import]) => !isInSkipList(_import, skipList))
+        .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
 }

package/src/lib/core/build-for-federation.js

@@ -5,62 +5,63 @@ import { writeImportMap } from './write-import-map.js';
 import { logger } from '../utils/logger.js';
 import { normalizePackageName } from '../utils/normalize.js';
 import { AbortedError } from '../utils/errors.js';
-import { resolveProjectName } from '../utils/config-utils.js';
 import { addExternalsToCache } from './federation-cache.js';
 import path from 'path';
 export async function buildForFederation(config, fedOptions, externals, signal) {
-    // 1. Caching
-    fedOptions.federationCache.cachePath = path.join(fedOptions.federationCache.cachePath, resolveProjectName(config));
-    const start = process.hrtime();
-    // 2. Shared mappings and exposed modules
-    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
-    logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
-    if (signal?.aborted)
-        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
-    // 3. Externals
+    // 1. Setup
+    fedOptions.federationCache.cachePath = path.join(fedOptions.federationCache.cachePath, fedOptions.projectName);
+    logger.info('Building federation artifacts');
+    logger.notice("Skip packages you don't want to share in your federation config");
+    // 2. Externals
     if (fedOptions.federationCache.externals.length > 0) {
         logger.info('Checksum matched, re-using cached externals.');
     }
     if (fedOptions.federationCache.externals.length === 0) {
         const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(config.shared);
         if (Object.keys(sharedBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, { platform: 'browser', bundleName: 'browser-shared' });
-            logger.measure(start, '[build artifacts] - To bundle all shared browser externals');
+            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, { platform: 'browser', bundleName: 'browser-shared', chunks: config.chunks });
+            logger.measure(start, 'Step 2.1) Bundling all shared browser externals');
             addExternalsToCache(fedOptions.federationCache, sharedPackageInfoBrowser);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After shared-browser bundle');
         }
         if (Object.keys(sharedServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, { platform: 'node', bundleName: 'node-shared' });
-            logger.measure(start, '[build artifacts] - To bundle all shared node externals');
+            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, { platform: 'node', bundleName: 'node-shared', chunks: config.chunks });
+            logger.measure(start, 'Step 2.1) Bundling all shared node externals');
             addExternalsToCache(fedOptions.federationCache, sharedPackageInfoServer);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After shared-node bundle');
         }
         if (Object.keys(separateBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
             const start = process.hrtime();
             const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, { platform: 'browser' });
-            logger.measure(start, '[build artifacts] - To bundle all separate browser externals');
+            logger.measure(start, 'Step 2.2) Bundling all separate browser external packages');
             addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After separate-browser bundle');
         }
         if (Object.keys(separateServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
             const start = process.hrtime();
             const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, { platform: 'node' });
-            logger.measure(start, '[build artifacts] - To bundle all separate node externals');
+            logger.measure(start, 'Step 2.2) Bundling all separate node external packages');
             addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
         }
         if (signal?.aborted)
             throw new AbortedError('[buildForFederation] After separate-node bundle');
     }
+    // 2. Shared mappings and exposed modules
+    const start = process.hrtime();
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
+    logger.measure(start, 'Step 3) Bundling all internal libraries and exposed modules.');
+    if (signal?.aborted)
+        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
+    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
     const sharedMappingInfo = !artifactInfo
         ? describeSharedMappings(config, fedOptions)
         : artifactInfo.mappings;
@@ -102,13 +103,17 @@ async function bundleSeparatePackages(separateBrowser, externals, config, fedOpt
     for (const [key, shared] of Object.entries(separateBrowser)) {
         const packageName = shared.build === 'separate' ? key : inferPackageFromSecondary(key);
         if (!groupedByPackage[packageName]) {
-            groupedByPackage[packageName] = {};
+            groupedByPackage[packageName] = {
+                chunks: shared.chunks,
+                entries: {},
+            };
         }
-        groupedByPackage[packageName][key] = shared;
+        groupedByPackage[packageName].entries[key] = shared;
     }
-    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, sharedGroup]) => {
-        return bundleShared(sharedGroup, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), {
+    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, packageConfig]) => {
+        return bundleShared(packageConfig.entries, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), {
             platform: buildOptions.platform,
+            chunks: packageConfig.chunks,
             bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`,
         });
     });
@@ -121,11 +126,6 @@ async function bundleSeparatePackages(separateBrowser, externals, config, fedOpt
         return { externals: [...acc.externals, ...r.externals], chunks };
     }, { externals: [] });
 }
-function notifyBundling(platform) {
-    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) {
     const sharedServer = {};
     const sharedBrowser = {};

package/src/lib/core/bundle-exposed-and-mappings.js

@@ -10,11 +10,12 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
     if (signal?.aborted) {
         throw new AbortedError('[bundle-exposed-and-mappings] Aborted before bundling');
     }
-    const shared = config.sharedMappings.map(sm => {
-        const entryPoint = sm.path;
-        const tmp = sm.key.replace(/[^A-Za-z0-9]/g, '_');
-        const outFilePath = tmp + '.js';
-        return { fileName: entryPoint, outName: outFilePath, key: sm.key };
+    const shared = Object.entries(config.sharedMappings).map(([entryPoint, mappedImport]) => {
+        return {
+            fileName: entryPoint,
+            outName: mappedImport.replace(/[^A-Za-z0-9]/g, '_') + '.js',
+            key: mappedImport,
+        };
     });
     const exposes = Object.entries(config.exposes).map(([key, entry]) => {
         const outFilePath = key + '.js';
@@ -22,11 +23,10 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
     });
     const entryPoints = [...shared, ...exposes];
     const hash = !fedOptions.dev;
-    logger.info('Building federation artifacts');
     let result;
     try {
         if (!modifiedFiles) {
-            await getBuildAdapter().setup({
+            await getBuildAdapter().setup('mapping-or-exposed', {
                 entryPoints,
                 outdir: fedOptions.outputPath,
                 tsConfigPath: fedOptions.tsConfig,
@@ -34,18 +34,16 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
                 dev: !!fedOptions.dev,
                 watch: fedOptions.watch,
                 mappedPaths: config.sharedMappings,
-                bundleName: 'mapping-or-exposed',
-                chunks: (typeof fedOptions.chunks === 'boolean' && fedOptions.chunks) ||
-                    (typeof fedOptions.chunks === 'object' && !!fedOptions.chunks.enable),
+                chunks: config.chunks,
                 hash,
                 optimizedMappings: config.features.ignoreUnusedDeps,
-                isNodeModules: false,
+                isMappingOrExposed: true,
                 cache: fedOptions.federationCache,
             });
         }
         result = await getBuildAdapter().build('mapping-or-exposed', {
             signal,
-            files: modifiedFiles,
+            modifiedFiles,
         });
         if (signal?.aborted) {
             throw new AbortedError('[bundle-exposed-and-mappings] Aborted after bundle');
@@ -99,7 +97,7 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, mo
         .forEach(f => popFromResultMap(resultMap, f));
     // Process remaining chunks and lazy loaded internal modules
     let exportedChunks = undefined;
-    if (typeof fedOptions.chunks === 'object' && fedOptions.chunks.dense === true) {
+    if (config.chunks && config.features.denseChunking) {
         for (const entryFile of entryFiles)
             rewriteChunkImports(entryFile);
         exportedChunks = {
@@ -126,18 +124,18 @@ export function describeExposed(config, options) {
 }
 export function describeSharedMappings(config, fedOptions) {
     const result = [];
-    for (const m of config.sharedMappings) {
+    for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
         result.push({
-            packageName: m.key,
+            packageName: mappedImport,
             outFileName: '',
             requiredVersion: '',
             singleton: true,
             strictVersion: false,
-            version: config.features.mappingVersion ? getMappingVersion(m.path) : '',
+            version: config.features.mappingVersion ? getMappingVersion(mappedPath) : '',
             dev: !fedOptions.dev
                 ? undefined
                 : {
-                    entryPoint: normalize(path.normalize(m.path)),
+                    entryPoint: normalize(path.normalize(mappedPath)),
                 },
         });
     }

package/src/lib/core/bundle-shared.d.ts

@@ -5,6 +5,7 @@ import type { NormalizedExternalConfig } from '../domain/config/external-config.
 export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
     platform: 'browser' | 'node';
     bundleName: string;
+    chunks: boolean;
 }): Promise<{
     externals: SharedInfo[];
     chunks?: Record<string, string[]>;

package/src/lib/core/bundle-shared.js

@@ -53,18 +53,16 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
     const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
     let bundleResult = null;
     try {
-        await getBuildAdapter().setup({
+        await getBuildAdapter().setup(buildOptions.bundleName, {
             entryPoints,
             tsConfigPath: fedOptions.tsConfig,
             external: [...additionalExternals, ...externals],
             outdir: fedOptions.federationCache.cachePath,
             mappedPaths: config.sharedMappings,
             dev: fedOptions.dev,
-            bundleName: buildOptions.bundleName,
-            isNodeModules: true,
+            isMappingOrExposed: false,
             hash: false,
-            chunks: (typeof fedOptions.chunks === 'boolean' && fedOptions.chunks) ||
-                (typeof fedOptions.chunks === 'object' && !!fedOptions.chunks.enable),
+            chunks: buildOptions.chunks,
             platform: buildOptions.platform,
             optimizedMappings: config.features.ignoreUnusedDeps,
             cache: fedOptions.federationCache,
@@ -102,11 +100,13 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
      * Chunking
      */
     let exportedChunks = undefined;
-    if (typeof fedOptions.chunks === 'object' && fedOptions.chunks.dense === true) {
+    if (buildOptions.chunks && config.features.denseChunking) {
         result.forEach(external => {
             external.bundle = buildOptions.bundleName;
         });
-        exportedChunks = { [buildOptions.bundleName]: getChunkFileNames(chunks) };
+        if (chunks.length > 0) {
+            exportedChunks = { [buildOptions.bundleName]: getChunkFileNames(chunks) };
+        }
     }
     else {
         addChunksToResult(chunks, result);
@@ -115,6 +115,7 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
         checksum,
         externals: result,
         files: bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName),
+        chunks: exportedChunks,
     });
     bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
     return { externals: result, chunks: exportedChunks };

package/src/lib/core/federation-builder.d.ts

@@ -7,10 +7,15 @@ export interface BuildHelperParams {
     adapter: NFBuildAdapter;
 }
 declare function init(params: BuildHelperParams): Promise<void>;
-declare function build(signal?: AbortSignal): Promise<void>;
+declare function build(opts?: {
+    modifiedFiles?: string[];
+    signal?: AbortSignal;
+}): Promise<void>;
+declare function close(): Promise<void>;
 export declare const federationBuilder: {
     init: typeof init;
     build: typeof build;
+    close: typeof close;
     readonly federationInfo: FederationInfo;
     readonly externals: string[];
     readonly config: NormalizedFederationConfig;

package/src/lib/core/federation-builder.js

@@ -1,28 +1,38 @@
 import { getConfigContext, usePackageJson, useWorkspace } from '../config/configuration-context.js';
-import { setBuildAdapter } from './build-adapter.js';
+import { getBuildAdapter, setBuildAdapter } from './build-adapter.js';
 import { buildForFederation } from './build-for-federation.js';
 import { getExternals } from './get-externals.js';
-import { loadFederationConfig } from './load-federation-config.js';
-import { normalizeFederationOptions } from './normalize-federation-options.js';
+import { normalizeFederationOptions } from './normalize-options.js';
+import { rebuildForFederation } from './rebuild-for-federation.js';
 let externals = [];
 let config;
-let fedOptions;
+let options;
 let fedInfo;
 async function init(params) {
     setBuildAdapter(params.adapter);
-    fedOptions = normalizeFederationOptions(params.options);
     useWorkspace(params.options.workspaceRoot);
     usePackageJson(params.options.packageJson);
-    config = await loadFederationConfig(fedOptions);
     params.options.workspaceRoot = getConfigContext().workspaceRoot ?? params.options.workspaceRoot;
+    const normalized = await normalizeFederationOptions(params.options);
+    options = normalized.options;
+    config = normalized.config;
     externals = getExternals(config);
 }
-async function build(signal) {
-    fedInfo = await buildForFederation(config, fedOptions, externals, signal);
+async function build(opts = {}) {
+    if (!fedInfo) {
+        fedInfo = await buildForFederation(config, options, externals, opts.signal);
+    }
+    else {
+        fedInfo = await rebuildForFederation(config, options, externals, opts.modifiedFiles ?? [], opts.signal);
+    }
+}
+async function close() {
+    return getBuildAdapter().dispose();
 }
 export const federationBuilder = {
     init,
     build,
+    close,
     get federationInfo() {
         return fedInfo;
     },