@softarc/native-federation 4.0.0-RC5 → 4.0.0-RC6

package/package.json

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

package/src/index.d.ts

@@ -1,5 +1,8 @@
 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';

package/src/index.js

@@ -1,5 +1,8 @@
 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';

package/src/internal.d.ts

@@ -9,3 +9,4 @@ export { createBuildResultMap, lookupInResultMap, popFromResultMap, } from './li
 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';

package/src/internal.js

@@ -6,3 +6,4 @@ export { RebuildQueue } 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 { getDefaultCachePath, getChecksum } from './lib/utils/cache-persistence.js';

package/src/lib/core/build-adapter.js

@@ -1,12 +1,12 @@
 import { logger } from '../utils/logger.js';
-let _buildAdapter = async () => {
-    // TODO: add logger
-    logger.error('NF is missing a build adapter!');
-    return [];
-};
+let _buildAdapter = null;
 export function setBuildAdapter(buildAdapter) {
     _buildAdapter = buildAdapter;
 }
 export function getBuildAdapter() {
+    if (!_buildAdapter) {
+        logger.error('Please set a BuildAdapter!');
+        throw new Error('BuildAdapter not set');
+    }
     return _buildAdapter;
 }

package/src/lib/core/build-for-federation.d.ts

@@ -1,6 +1,4 @@
 import type { FederationInfo } from '../domain/core/federation-info.contract.js';
-import type { FederationOptions } from '../domain/core/federation-options.contract.js';
+import type { NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import type { BuildParams } from '../domain/core/build-params.contract.js';
-export declare const defaultBuildParams: BuildParams;
-export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], buildParams?: BuildParams): Promise<FederationInfo>;
+export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -3,66 +3,60 @@ import { bundleShared } from './bundle-shared.js';
 import { writeFederationInfo } from './write-federation-info.js';
 import { writeImportMap } from './write-import-map.js';
 import { logger } from '../utils/logger.js';
-import { getCachePath } from './../utils/bundle-caching.js';
 import { normalizePackageName } from '../utils/normalize.js';
 import { AbortedError } from '../utils/errors.js';
 import { resolveProjectName } from '../utils/config-utils.js';
-export const defaultBuildParams = {
-    skipMappingsAndExposed: false,
-    skipShared: false,
-};
-const sharedCache = { externals: [] };
-export async function buildForFederation(config, fedOptions, externals, buildParams = defaultBuildParams) {
-    const signal = buildParams.signal;
-    let artifactInfo;
-    if (!buildParams.skipMappingsAndExposed) {
-        const start = process.hrtime();
-        artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, signal);
-        logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
-        if (signal?.aborted)
-            throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    }
+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;
-    const cacheProjectFolder = resolveProjectName(config);
-    const pathToCache = getCachePath(fedOptions.workspaceRoot, cacheProjectFolder);
-    if (!buildParams.skipShared && sharedCache.externals.length > 0) {
+    // 3. Externals
+    if (fedOptions.federationCache.externals.length > 0) {
         logger.info('Checksum matched, re-using cached externals.');
     }
-    if (!buildParams.skipShared && sharedCache.externals.length === 0) {
+    if (fedOptions.federationCache.externals.length === 0) {
         const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(config.shared);
         if (Object.keys(sharedBrowser).length > 0) {
             notifyBundling('browser-shared');
             const start = process.hrtime();
-            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, 'browser', { pathToCache, bundleName: 'browser-shared' });
+            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, { platform: 'browser', bundleName: 'browser-shared' });
             logger.measure(start, '[build artifacts] - To bundle all shared browser externals');
-            addToCache(sharedPackageInfoBrowser);
+            addExternalsToCache(fedOptions.federationCache, 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' });
+            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, { platform: 'node', bundleName: 'node-shared' });
             logger.measure(start, '[build artifacts] - To bundle all shared node externals');
-            addToCache(sharedPackageInfoServer);
+            addExternalsToCache(fedOptions.federationCache, 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, 'browser', pathToCache);
+            const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, { platform: 'browser' });
             logger.measure(start, '[build artifacts] - To bundle all separate browser externals');
-            addToCache(separatePackageInfoBrowser);
+            addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
             if (signal?.aborted)
                 throw new AbortedError('[buildForFederation] After separate-browser bundle');
         }
         if (Object.keys(separateServer).length > 0) {
             notifyBundling('browser-shared');
             const start = process.hrtime();
-            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, 'node', pathToCache);
+            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, { platform: 'node' });
             logger.measure(start, '[build artifacts] - To bundle all separate node externals');
-            addToCache(separatePackageInfoServer);
+            addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
         }
         if (signal?.aborted)
             throw new AbortedError('[buildForFederation] After separate-node bundle');
@@ -70,7 +64,7 @@ export async function buildForFederation(config, fedOptions, externals, buildPar
     const sharedMappingInfo = !artifactInfo
         ? describeSharedMappings(config, fedOptions)
         : artifactInfo.mappings;
-    const sharedExternals = [...sharedCache.externals, ...sharedMappingInfo];
+    const sharedExternals = [...fedOptions.federationCache.externals, ...sharedMappingInfo];
     if (config?.shareScope) {
         Object.values(sharedExternals).forEach(external => {
             if (!external.shareScope)
@@ -86,24 +80,16 @@ export async function buildForFederation(config, fedOptions, externals, buildPar
         exposes: exposedInfo,
         buildNotificationsEndpoint,
     };
-    if (sharedCache.chunks) {
-        federationInfo.chunks = sharedCache.chunks;
+    if (fedOptions.federationCache.chunks) {
+        federationInfo.chunks = fedOptions.federationCache.chunks;
     }
     if (artifactInfo?.chunks) {
         federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
     }
     writeFederationInfo(federationInfo, fedOptions);
-    writeImportMap(sharedCache, fedOptions);
+    writeImportMap(fedOptions.federationCache, fedOptions);
     return federationInfo;
 }
-function addToCache({ externals, chunks }) {
-    sharedCache.externals.push(...externals);
-    if (chunks) {
-        if (!sharedCache.chunks)
-            sharedCache.chunks = {};
-        sharedCache.chunks = { ...sharedCache.chunks, ...chunks };
-    }
-}
 function inferPackageFromSecondary(secondary) {
     const parts = secondary.split('/');
     if (secondary.startsWith('@') && parts.length >= 2) {
@@ -111,7 +97,7 @@ function inferPackageFromSecondary(secondary) {
     }
     return parts[0];
 }
-async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, platform, pathToCache) {
+async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, buildOptions) {
     const groupedByPackage = {};
     for (const [key, shared] of Object.entries(separateBrowser)) {
         const packageName = shared.build === 'separate' ? key : inferPackageFromSecondary(key);
@@ -121,7 +107,10 @@ async function bundleSeparatePackages(separateBrowser, externals, config, fedOpt
         groupedByPackage[packageName][key] = shared;
     }
     const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, sharedGroup]) => {
-        return bundleShared(sharedGroup, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), platform, { pathToCache, bundleName: `${platform}-${normalizePackageName(packageName)}` });
+        return bundleShared(sharedGroup, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), {
+            platform: buildOptions.platform,
+            bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`,
+        });
     });
     const buildResults = await Promise.all(bundlePromises);
     return buildResults.reduce((acc, r) => {

package/src/lib/core/bundle-exposed-and-mappings.d.ts

@@ -1,6 +1,6 @@
 import type { ArtifactInfo, ExposesInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import { type FederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
-export declare function describeExposed(config: NormalizedFederationConfig, options: FederationOptions): Array<ExposesInfo>;
-export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions): Array<SharedInfo>;
+import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
+export declare function describeExposed(config: NormalizedFederationConfig, options: NormalizedFederationOptions): Array<ExposesInfo>;
+export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions): Array<SharedInfo>;

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

@@ -1,12 +1,12 @@
 import fs from 'fs';
 import path from 'path';
 import { createBuildResultMap, popFromResultMap } from '../utils/build-result-map.js';
-import { bundle } from '../utils/build-utils.js';
 import { logger } from '../utils/logger.js';
 import { normalize } from '../utils/normalize.js';
 import { AbortedError } from '../utils/errors.js';
 import { rewriteChunkImports } from '../utils/rewrite-chunk-imports.js';
-export async function bundleExposedAndMappings(config, fedOptions, externals, signal) {
+import { getBuildAdapter } from './build-adapter.js';
+export async function bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal) {
     if (signal?.aborted) {
         throw new AbortedError('[bundle-exposed-and-mappings] Aborted before bundling');
     }
@@ -25,20 +25,27 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, si
     logger.info('Building federation artifacts');
     let result;
     try {
-        result = await bundle({
-            entryPoints,
-            outdir: fedOptions.outputPath,
-            tsConfigPath: fedOptions.tsConfig,
-            external: externals,
-            dev: !!fedOptions.dev,
-            watch: fedOptions.watch,
-            mappedPaths: config.sharedMappings,
-            kind: 'mapping-or-exposed',
-            chunks: (typeof fedOptions.chunks === 'boolean' && fedOptions.chunks) ||
-                (typeof fedOptions.chunks === 'object' && !!fedOptions.chunks.enable),
-            hash,
-            optimizedMappings: config.features.ignoreUnusedDeps,
+        if (!modifiedFiles) {
+            await getBuildAdapter().setup({
+                entryPoints,
+                outdir: fedOptions.outputPath,
+                tsConfigPath: fedOptions.tsConfig,
+                external: externals,
+                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),
+                hash,
+                optimizedMappings: config.features.ignoreUnusedDeps,
+                isNodeModules: false,
+                cache: fedOptions.federationCache,
+            });
+        }
+        result = await getBuildAdapter().build('mapping-or-exposed', {
             signal,
+            files: modifiedFiles,
         });
         if (signal?.aborted) {
             throw new AbortedError('[bundle-exposed-and-mappings] Aborted after bundle');

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

@@ -1,9 +1,9 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 import type { SharedInfo } from '../domain/core/federation-info.contract.js';
-import { type FederationOptions } from '../domain/core/federation-options.contract.js';
+import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
 import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
-export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], platform: "browser" | "node" | undefined, buildOptions: {
-    pathToCache: string;
+export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
+    platform: 'browser' | 'node';
     bundleName: string;
 }): Promise<{
     externals: SharedInfo[];

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

@@ -1,20 +1,20 @@
 import * as path from 'path';
 import * as fs from 'fs';
-import { bundle } from '../utils/build-utils.js';
 import { getPackageInfo } from '../utils/package-info.js';
 import { logger } from '../utils/logger.js';
 import crypto from 'crypto';
 import { DEFAULT_EXTERNAL_LIST } from './default-external-list.js';
 import { isSourceFile, rewriteChunkImports } from '../utils/rewrite-chunk-imports.js';
 import { toChunkImport } from '../domain/core/chunk.js';
-import { cacheEntry, getChecksum, getFilename } from './../utils/bundle-caching.js';
+import { cacheEntry, getChecksum, getFilename } from '../utils/cache-persistence.js';
 import { fileURLToPath } from 'url';
-export async function bundleShared(sharedBundles, config, fedOptions, externals, platform = 'browser', buildOptions) {
+import { getBuildAdapter } from './build-adapter.js';
+export async function bundleShared(sharedBundles, config, fedOptions, externals, buildOptions) {
     const checksum = getChecksum(sharedBundles, fedOptions.dev ? '1' : '0');
     const folder = fedOptions.packageJson
         ? path.dirname(fedOptions.packageJson)
         : fedOptions.workspaceRoot;
-    const bundleCache = cacheEntry(buildOptions.pathToCache, getFilename(buildOptions.bundleName, fedOptions.dev));
+    const bundleCache = cacheEntry(fedOptions.federationCache.cachePath, getFilename(buildOptions.bundleName, fedOptions.dev));
     if (fedOptions?.cacheExternalArtifacts) {
         const cacheMetadata = bundleCache.getMetadata(checksum);
         if (cacheMetadata) {
@@ -46,29 +46,33 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
     });
     const fullOutputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
     const expectedResults = allEntryPoints.map(ep => path.join(fullOutputPath, ep.outName));
-    const entryPoints = allEntryPoints.filter(ep => !fs.existsSync(path.join(buildOptions.pathToCache, ep.outName)));
+    const entryPoints = allEntryPoints.filter(ep => !fs.existsSync(path.join(fedOptions.federationCache.cachePath, ep.outName)));
     // 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 = platform === 'browser' && !config.features.ignoreUnusedDeps;
+    const useDefaultExternalList = buildOptions.platform === 'browser' && !config.features.ignoreUnusedDeps;
     const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
     let bundleResult = null;
     try {
-        bundleResult = await bundle({
+        await getBuildAdapter().setup({
             entryPoints,
             tsConfigPath: fedOptions.tsConfig,
             external: [...additionalExternals, ...externals],
-            outdir: buildOptions.pathToCache,
+            outdir: fedOptions.federationCache.cachePath,
             mappedPaths: config.sharedMappings,
             dev: fedOptions.dev,
-            kind: 'shared-package',
+            bundleName: buildOptions.bundleName,
+            isNodeModules: true,
             hash: false,
             chunks: (typeof fedOptions.chunks === 'boolean' && fedOptions.chunks) ||
                 (typeof fedOptions.chunks === 'object' && !!fedOptions.chunks.enable),
-            platform,
+            platform: buildOptions.platform,
             optimizedMappings: config.features.ignoreUnusedDeps,
+            cache: fedOptions.federationCache,
         });
+        bundleResult = await getBuildAdapter().build(buildOptions.bundleName);
+        await getBuildAdapter().dispose(buildOptions.bundleName);
         const cachedFiles = bundleResult.map(br => path.basename(br.fileName));
-        rewriteImports(cachedFiles, buildOptions.pathToCache);
+        rewriteImports(cachedFiles, fedOptions.federationCache.cachePath);
     }
     catch (e) {
         logger.error('Error bundling shared npm package ');

package/src/lib/core/default-external-list.js

@@ -26,7 +26,4 @@ const NODE_PACKAGES = [
     'vm',
     'zlib',
 ];
-export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap((p) => [
-    p,
-    'node:' + p,
-]);
+export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap(p => [p, 'node:' + p]);

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

@@ -7,7 +7,7 @@ export interface BuildHelperParams {
     adapter: NFBuildAdapter;
 }
 declare function init(params: BuildHelperParams): Promise<void>;
-declare function build(buildParams?: import("../../domain.js").BuildParams): Promise<void>;
+declare function build(signal?: AbortSignal): Promise<void>;
 export declare const federationBuilder: {
     init: typeof init;
     build: typeof build;

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

@@ -1,23 +1,24 @@
 import { getConfigContext, usePackageJson, useWorkspace } from '../config/configuration-context.js';
 import { setBuildAdapter } from './build-adapter.js';
-import { buildForFederation, defaultBuildParams } from './build-for-federation.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';
 let externals = [];
 let config;
 let fedOptions;
 let fedInfo;
 async function init(params) {
     setBuildAdapter(params.adapter);
-    fedOptions = params.options;
+    fedOptions = normalizeFederationOptions(params.options);
     useWorkspace(params.options.workspaceRoot);
     usePackageJson(params.options.packageJson);
     config = await loadFederationConfig(fedOptions);
     params.options.workspaceRoot = getConfigContext().workspaceRoot ?? params.options.workspaceRoot;
     externals = getExternals(config);
 }
-async function build(buildParams = defaultBuildParams) {
-    fedInfo = await buildForFederation(config, fedOptions, externals, buildParams);
+async function build(signal) {
+    fedInfo = await buildForFederation(config, fedOptions, externals, signal);
 }
 export const federationBuilder = {
     init,

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

@@ -0,0 +1,8 @@
+import type { FederationCache } from '../domain/core/federation-cache.contract.js';
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+export declare function createFederationCache(cachePath: string): FederationCache<undefined>;
+export declare function createFederationCache<TBundlerCache>(cachePath: string, bundlerCache: TBundlerCache): FederationCache<TBundlerCache>;
+export declare function addExternalsToCache(cache: FederationCache, { externals, chunks }: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}): void;

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

@@ -0,0 +1,11 @@
+export function createFederationCache(cachePath, bundlerCache) {
+    return { externals: [], cachePath, bundlerCache };
+}
+export function addExternalsToCache(cache, { externals, chunks }) {
+    cache.externals.push(...externals);
+    if (chunks) {
+        if (!cache.chunks)
+            cache.chunks = {};
+        cache.chunks = { ...cache.chunks, ...chunks };
+    }
+}

package/src/lib/core/normalize-federation-options.d.ts

@@ -0,0 +1,4 @@
+import type { FederationCache } from '../../domain.js';
+import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+export declare function normalizeFederationOptions(options: FederationOptions): NormalizedFederationOptions<undefined>;
+export declare function normalizeFederationOptions<TBundlerCache>(options: FederationOptions, cache: FederationCache<TBundlerCache>): NormalizedFederationOptions<TBundlerCache>;

package/src/lib/core/normalize-federation-options.js

@@ -0,0 +1,10 @@
+import { getDefaultCachePath } from '../utils/cache-persistence.js';
+import { createFederationCache } from './federation-cache.js';
+export function normalizeFederationOptions(options, cache) {
+    const federationCache = cache ??
+        createFederationCache(getDefaultCachePath(options.workspaceRoot));
+    return {
+        ...options,
+        federationCache,
+    };
+}

package/src/lib/core/rebuild-for-federation.d.ts

@@ -0,0 +1,4 @@
+import type { FederationInfo } from '../domain/core/federation-info.contract.js';
+import type { NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+export declare function rebuildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -0,0 +1,37 @@
+import { bundleExposedAndMappings, describeExposed, describeSharedMappings, } from './bundle-exposed-and-mappings.js';
+import { writeFederationInfo } from './write-federation-info.js';
+import { writeImportMap } from './write-import-map.js';
+import { logger } from '../utils/logger.js';
+import { AbortedError } from '../utils/errors.js';
+export async function rebuildForFederation(config, fedOptions, externals, modifiedFiles, signal) {
+    const federationCache = fedOptions.federationCache;
+    const start = process.hrtime();
+    // Shared mappings and exposed modules
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal);
+    logger.measure(start, '[build artifacts] - To re-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;
+    const sharedMappingInfo = !artifactInfo
+        ? describeSharedMappings(config, fedOptions)
+        : artifactInfo.mappings;
+    const sharedExternals = [...federationCache.externals, ...sharedMappingInfo];
+    const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
+        ? fedOptions.buildNotifications?.endpoint
+        : undefined;
+    const federationInfo = {
+        name: config.name,
+        shared: sharedExternals,
+        exposes: exposedInfo,
+        buildNotificationsEndpoint,
+    };
+    if (federationCache.chunks) {
+        federationInfo.chunks = federationCache.chunks;
+    }
+    if (artifactInfo?.chunks) {
+        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
+    }
+    writeFederationInfo(federationInfo, fedOptions);
+    writeImportMap(federationCache, fedOptions);
+    return federationInfo;
+}

package/src/lib/domain/core/build-adapter.contract.d.ts

@@ -1,27 +1,33 @@
 import type { MappedPath } from '../utils/mapped-path.contract.js';
-export type NFBuildAdapter = (options: NFBuildAdapterOptions) => Promise<NFBuildAdapterResult[]>;
-export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed' | 'mapping-or-exposed';
+import type { FederationCache } from './federation-cache.contract.js';
+export interface NFBuildAdapter {
+    setup(options: NFBuildAdapterOptions): Promise<void>;
+    build(name: string, opts?: {
+        files?: string[];
+        signal?: AbortSignal;
+    }): Promise<NFBuildAdapterResult[]>;
+    dispose(name?: string): Promise<void>;
+}
 export interface EntryPoint {
     fileName: string;
     outName: string;
     key?: string;
 }
-export interface NFBuildAdapterOptions {
+export interface NFBuildAdapterOptions<TBundlerCache = unknown> {
     entryPoints: EntryPoint[];
     tsConfigPath?: string;
-    external: Array<string>;
+    external: string[];
     outdir: string;
     mappedPaths: MappedPath[];
-    packageName?: string;
-    esm?: boolean;
+    bundleName: string;
+    isNodeModules: boolean;
     dev?: boolean;
     watch?: boolean;
     chunks?: boolean;
-    kind: BuildKind;
     hash: boolean;
     platform?: 'browser' | 'node';
     optimizedMappings?: boolean;
-    signal?: AbortSignal;
+    cache: FederationCache<TBundlerCache>;
 }
 export interface NFBuildAdapterResult {
     fileName: string;

package/src/lib/domain/core/federation-cache.contract.d.ts

@@ -0,0 +1,7 @@
+import type { ChunkInfo, SharedInfo } from './federation-info.contract.js';
+export type FederationCache<TBundlerCache = unknown> = {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+    bundlerCache: TBundlerCache;
+    cachePath: string;
+};

package/src/lib/domain/core/federation-options.contract.d.ts

@@ -1,4 +1,5 @@
 import type { BuildNotificationOptions } from './build-notification-options.contract.js';
+import type { FederationCache } from './federation-cache.contract.js';
 export interface FederationOptions {
     workspaceRoot: string;
     outputPath: string;
@@ -16,3 +17,6 @@ export interface FederationOptions {
     entryPoint?: string;
     buildNotifications?: BuildNotificationOptions;
 }
+export interface NormalizedFederationOptions<TBundlerCache = unknown> extends FederationOptions {
+    federationCache: FederationCache<TBundlerCache>;
+}

package/src/lib/domain/core/index.d.ts

@@ -1,6 +1,6 @@
 export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, } from './federation-info.contract.js';
 export { type BuildNotificationOptions, BuildNotificationType, } from './build-notification-options.contract.js';
-export type { FederationOptions } from './federation-options.contract.js';
-export type { BuildKind, EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, } from './build-adapter.contract.js';
-export type { BuildParams } from './build-params.contract.js';
+export type { FederationOptions, NormalizedFederationOptions, } from './federation-options.contract.js';
+export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, } from './build-adapter.contract.js';
 export { CHUNK_PREFIX, toChunkImport } from './chunk.js';
+export type { FederationCache } from './federation-cache.contract.js';

package/src/lib/utils/{bundle-caching.d.ts → cache-persistence.d.ts}

@@ -1,6 +1,6 @@
 import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
 import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
-export declare const getCachePath: (workspaceRoot: string, project: string) => string;
+export declare const getDefaultCachePath: (workspaceRoot: string) => string;
 export declare const getFilename: (title: string, dev?: boolean) => string;
 export declare const getChecksum: (shared: Record<string, NormalizedExternalConfig>, dev: "1" | "0") => string;
 export declare const cacheEntry: (pathToCache: string, fileName: string) => {

package/src/lib/utils/{bundle-caching.js → cache-persistence.js}

@@ -1,8 +1,8 @@
 import path from 'path';
 import fs from 'fs';
 import crypto from 'crypto';
-import { logger } from '../utils/logger.js';
-export const getCachePath = (workspaceRoot, project) => path.join(workspaceRoot, 'node_modules/.cache/native-federation', project);
+import { logger } from './logger.js';
+export const getDefaultCachePath = (workspaceRoot) => path.join(workspaceRoot, 'node_modules/.cache/native-federation');
 export const getFilename = (title, dev) => {
     const devSuffix = dev ? '-dev' : '';
     return `${title}${devSuffix}.meta.json`;

package/src/lib/utils/resolve-glob.js

@@ -15,13 +15,13 @@ export function resolveGlobSync(pattern, baseDir = process.cwd()) {
         const entries = fs.readdirSync(dir, { withFileTypes: true });
         if (segment === '*') {
             entries
-                .filter((entry) => entry.isDirectory())
-                .forEach((entry) => search(path.join(dir, entry.name), segmentIndex + 1));
+                .filter(entry => entry.isDirectory())
+                .forEach(entry => search(path.join(dir, entry.name), segmentIndex + 1));
         }
         else {
             entries
-                .filter((entry) => entry.name === segment)
-                .forEach((entry) => search(path.join(dir, entry.name), segmentIndex + 1));
+                .filter(entry => entry.name === segment)
+                .forEach(entry => search(path.join(dir, entry.name), segmentIndex + 1));
         }
     }
     search(baseDir, 0);

package/src/lib/domain/core/build-params.contract.d.ts

@@ -1,5 +0,0 @@
-export interface BuildParams {
-    skipMappingsAndExposed: boolean;
-    skipShared: boolean;
-    signal?: AbortSignal;
-}

package/src/lib/utils/build-utils.d.ts

@@ -1,2 +0,0 @@
-import type { NFBuildAdapterOptions } from '../domain/core/build-adapter.contract.js';
-export declare function bundle(options: NFBuildAdapterOptions): Promise<import("../domain/core/build-adapter.contract.js").NFBuildAdapterResult[]>;

package/src/lib/utils/build-utils.js

@@ -1,5 +0,0 @@
-import { getBuildAdapter } from '../core/build-adapter.js';
-export async function bundle(options) {
-    const adapter = getBuildAdapter();
-    return await adapter(options);
-}