@softarc/native-federation 3.5.5 → 4.0.0-RC10

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

@@ -1,96 +1,115 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundleExposedAndMappings = bundleExposedAndMappings;
-exports.describeExposed = describeExposed;
-exports.describeSharedMappings = describeSharedMappings;
-const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const build_result_map_1 = require("../utils/build-result-map");
-const build_utils_1 = require("../utils/build-utils");
-const logger_1 = require("../utils/logger");
-const normalize_1 = require("../utils/normalize");
-const errors_1 = require("../utils/errors");
-async function bundleExposedAndMappings(config, fedOptions, externals, signal) {
+import fs from 'fs';
+import path from 'path';
+import { createBuildResultMap, popFromResultMap } from '../utils/build-result-map.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';
+import { getBuildAdapter } from './build-adapter.js';
+export async function bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal) {
     if (signal?.aborted) {
-        throw new errors_1.AbortedError('[bundle-exposed-and-mappings] Aborted before bundling');
+        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.keys(config.exposes).map((key) => {
-        const entryPoint = config.exposes[key];
+    const exposes = Object.entries(config.exposes).map(([key, entry]) => {
         const outFilePath = key + '.js';
-        return { fileName: entryPoint, outName: outFilePath, key };
+        return { fileName: entry, outName: outFilePath, key };
     });
     const entryPoints = [...shared, ...exposes];
     const hash = !fedOptions.dev;
-    logger_1.logger.info('Building federation artefacts');
     let result;
     try {
-        result = await (0, build_utils_1.bundle)({
-            entryPoints,
-            outdir: fedOptions.outputPath,
-            tsConfigPath: fedOptions.tsConfig,
-            external: externals,
-            dev: !!fedOptions.dev,
-            watch: fedOptions.watch,
-            mappedPaths: config.sharedMappings,
-            kind: 'mapping-or-exposed',
-            hash,
-            optimizedMappings: config.features.ignoreUnusedDeps,
+        if (!modifiedFiles) {
+            await getBuildAdapter().setup('mapping-or-exposed', {
+                entryPoints,
+                outdir: fedOptions.outputPath,
+                tsConfigPath: fedOptions.tsConfig,
+                external: externals,
+                dev: !!fedOptions.dev,
+                watch: fedOptions.watch,
+                mappedPaths: config.sharedMappings,
+                chunks: config.chunks,
+                hash,
+                optimizedMappings: config.features.ignoreUnusedDeps,
+                isMappingOrExposed: true,
+                cache: fedOptions.federationCache,
+            });
+        }
+        result = await getBuildAdapter().build('mapping-or-exposed', {
             signal,
+            modifiedFiles,
         });
         if (signal?.aborted) {
-            throw new errors_1.AbortedError('[bundle-exposed-and-mappings] Aborted after bundle');
+            throw new AbortedError('[bundle-exposed-and-mappings] Aborted after bundle');
         }
     }
     catch (error) {
-        if (!(error instanceof errors_1.AbortedError)) {
-            logger_1.logger.error('Error building federation artefacts');
+        if (!(error instanceof AbortedError)) {
+            logger.error('Error building federation artifacts');
         }
         throw error;
     }
-    const resultMap = (0, build_result_map_1.createBuildResultMap)(result, hash);
+    const resultMap = createBuildResultMap(result, hash);
     const sharedResult = [];
+    const entryFiles = [];
+    // Pick shared-mappings
     for (const item of shared) {
+        const distEntryFile = popFromResultMap(resultMap, item.outName);
         sharedResult.push({
             packageName: item.key,
-            outFileName: (0, build_result_map_1.lookupInResultMap)(resultMap, item.outName),
+            outFileName: path.basename(distEntryFile),
             requiredVersion: '',
             singleton: true,
             strictVersion: false,
-            version: config.features.mappingVersion
-                ? getMappingVersion(item.fileName)
-                : '',
+            version: config.features.mappingVersion ? getMappingVersion(item.fileName) : '',
             dev: !fedOptions.dev
                 ? undefined
                 : {
-                    entryPoint: (0, normalize_1.normalize)(path_1.default.normalize(item.fileName)),
+                    entryPoint: normalize(path.normalize(item.fileName)),
                 },
         });
+        entryFiles.push(distEntryFile);
     }
     const exposedResult = [];
+    // Pick exposed-modules
     for (const item of exposes) {
+        const distEntryFile = popFromResultMap(resultMap, item.outName);
         exposedResult.push({
             key: item.key,
-            outFileName: (0, build_result_map_1.lookupInResultMap)(resultMap, item.outName),
+            outFileName: path.basename(distEntryFile),
             dev: !fedOptions.dev
                 ? undefined
                 : {
-                    entryPoint: (0, normalize_1.normalize)(path_1.default.join(fedOptions.workspaceRoot, item.fileName)),
+                    entryPoint: normalize(path.join(fedOptions.workspaceRoot, item.fileName)),
                 },
         });
+        entryFiles.push(distEntryFile);
+    }
+    // Remove .map files
+    Object.keys(resultMap)
+        .filter(f => f.endsWith('.map'))
+        .forEach(f => popFromResultMap(resultMap, f));
+    // Process remaining chunks and lazy loaded internal modules
+    let exportedChunks = undefined;
+    if (config.chunks && config.features.denseChunking) {
+        for (const entryFile of entryFiles)
+            rewriteChunkImports(entryFile);
+        exportedChunks = {
+            ['mapping-or-exposed']: Object.values(resultMap).map(chunk => path.basename(chunk)),
+        };
     }
-    return { mappings: sharedResult, exposes: exposedResult };
+    return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks };
 }
-function describeExposed(config, options) {
+export function describeExposed(config, options) {
     const result = [];
     for (const key in config.exposes) {
-        const localPath = (0, normalize_1.normalize)(path_1.default.normalize(path_1.default.join(options.workspaceRoot, config.exposes[key])));
+        const localPath = normalize(path.normalize(path.join(options.workspaceRoot, config.exposes[key])));
         result.push({
             key,
             outFileName: '',
@@ -103,34 +122,33 @@ function describeExposed(config, options) {
     }
     return result;
 }
-function describeSharedMappings(config, fedOptions) {
+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: (0, normalize_1.normalize)(path_1.default.normalize(m.path)),
+                    entryPoint: normalize(path.normalize(mappedPath)),
                 },
         });
     }
     return result;
 }
 function getMappingVersion(fileName) {
-    const entryFileDir = path_1.default.dirname(fileName);
-    const cand1 = path_1.default.join(entryFileDir, 'package.json');
-    const cand2 = path_1.default.join(path_1.default.dirname(entryFileDir), 'package.json');
-    const packageJsonPath = [cand1, cand2].find((cand) => fs_1.default.existsSync(cand));
+    const entryFileDir = path.dirname(fileName);
+    const cand1 = path.join(entryFileDir, 'package.json');
+    const cand2 = path.join(path.dirname(entryFileDir), 'package.json');
+    const packageJsonPath = [cand1, cand2].find(cand => fs.existsSync(cand));
     if (packageJsonPath) {
-        const json = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        const json = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
         return json.version ?? '';
     }
     return '';
 }
-//# sourceMappingURL=bundle-exposed-and-mappings.js.map

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

@@ -1,7 +1,12 @@
-import { NormalizedFederationConfig, NormalizedSharedConfig } from '../config/federation-config';
-import { SharedInfo } from '@softarc/native-federation-runtime';
-import { FederationOptions } from './federation-options';
-export declare function bundleShared(sharedBundles: Record<string, NormalizedSharedConfig>, config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], platform: "browser" | "node" | undefined, cacheOptions: {
-    pathToCache: string;
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { SharedInfo } from '../domain/core/federation-info.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: NormalizedFederationOptions, externals: string[], buildOptions: {
+    platform: 'browser' | 'node';
     bundleName: string;
-}): Promise<Array<SharedInfo>>;
+    chunks: boolean;
+}): Promise<{
+    externals: SharedInfo[];
+    chunks?: Record<string, string[]>;
+}>;

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

@@ -1,135 +1,149 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.bundleShared = bundleShared;
-const tslib_1 = require("tslib");
-const path = tslib_1.__importStar(require("path"));
-const fs = tslib_1.__importStar(require("fs"));
-const build_utils_1 = require("../utils/build-utils");
-const package_info_1 = require("../utils/package-info");
-const logger_1 = require("../utils/logger");
-const crypto_1 = tslib_1.__importDefault(require("crypto"));
-const default_external_list_1 = require("./default-external-list");
-const rewrite_chunk_imports_1 = require("../utils/rewrite-chunk-imports");
-const bundle_caching_1 = require("./../utils/bundle-caching");
-async function bundleShared(sharedBundles, config, fedOptions, externals, platform = 'browser', cacheOptions) {
-    const checksum = (0, bundle_caching_1.getChecksum)(sharedBundles, fedOptions.dev ? '1' : '0');
+import * as path from 'path';
+import * as fs from 'fs';
+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/cache-persistence.js';
+import { fileURLToPath } from 'url';
+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 = (0, bundle_caching_1.cacheEntry)(cacheOptions.pathToCache, (0, bundle_caching_1.getFilename)(cacheOptions.bundleName, fedOptions.dev));
+    const bundleCache = cacheEntry(fedOptions.federationCache.cachePath, getFilename(buildOptions.bundleName, fedOptions.dev));
     if (fedOptions?.cacheExternalArtifacts) {
         const cacheMetadata = bundleCache.getMetadata(checksum);
         if (cacheMetadata) {
-            logger_1.logger.debug(`Checksum of ${cacheOptions.bundleName} matched, Skipped artifact bundling`);
+            logger.debug(`Checksum of ${buildOptions.bundleName} matched, Skipped artifact bundling`);
             bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-            return cacheMetadata.externals;
+            return { externals: cacheMetadata.externals, chunks: cacheMetadata.chunks };
         }
     }
     bundleCache.clear();
     const inferredPackageInfos = Object.keys(sharedBundles)
-        .filter((packageName) => !sharedBundles[packageName].packageInfo)
-        .map((packageName) => (0, package_info_1.getPackageInfo)(packageName, folder))
-        .filter((pi) => !!pi);
+        .filter(packageName => !sharedBundles[packageName]?.packageInfo)
+        .map(packageName => getPackageInfo(packageName, folder))
+        .filter(pi => !!pi);
     const configuredPackageInfos = Object.keys(sharedBundles)
-        .filter((packageName) => !!sharedBundles[packageName].packageInfo)
-        .map((packageName) => ({
+        .filter(packageName => !!sharedBundles[packageName]?.packageInfo)
+        .map(packageName => ({
         packageName,
-        ...sharedBundles[packageName].packageInfo,
+        ...sharedBundles[packageName]?.packageInfo,
     }));
     const packageInfos = [...inferredPackageInfos, ...configuredPackageInfos];
+    const __filename = fileURLToPath(import.meta.url);
     const configState = 'BUNDLER_CHUNKS' + // TODO: Replace this with lib version
-        fs.readFileSync(path.join(__dirname, '../../../package.json')) +
+        fs.readFileSync(path.join(path.dirname(__filename), '../../../package.json')) +
         JSON.stringify(config);
-    const allEntryPoints = packageInfos.map((pi) => {
+    const allEntryPoints = packageInfos.map(pi => {
         const encName = pi.packageName.replace(/[^A-Za-z0-9]/g, '_');
         const outName = createOutName(pi, configState, fedOptions, encName);
         return { fileName: pi.entryPoint, outName };
     });
     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(cacheOptions.pathToCache, ep.outName)));
+    const expectedResults = allEntryPoints.map(ep => path.join(fullOutputPath, 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 additionalExternals = useDefaultExternalList
-        ? default_external_list_1.DEFAULT_EXTERNAL_LIST
-        : [];
+    const useDefaultExternalList = buildOptions.platform === 'browser' && !config.features.ignoreUnusedDeps;
+    const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
     let bundleResult = null;
     try {
-        bundleResult = await (0, build_utils_1.bundle)({
+        await getBuildAdapter().setup(buildOptions.bundleName, {
             entryPoints,
             tsConfigPath: fedOptions.tsConfig,
             external: [...additionalExternals, ...externals],
-            outdir: cacheOptions.pathToCache,
+            outdir: fedOptions.federationCache.cachePath,
             mappedPaths: config.sharedMappings,
             dev: fedOptions.dev,
-            kind: 'shared-package',
+            isMappingOrExposed: false,
             hash: false,
-            platform,
+            chunks: buildOptions.chunks,
+            platform: buildOptions.platform,
             optimizedMappings: config.features.ignoreUnusedDeps,
+            cache: fedOptions.federationCache,
         });
-        const cachedFiles = bundleResult.map((br) => path.basename(br.fileName));
-        rewriteImports(cachedFiles, cacheOptions.pathToCache);
+        bundleResult = await getBuildAdapter().build(buildOptions.bundleName);
+        await getBuildAdapter().dispose(buildOptions.bundleName);
+        const cachedFiles = bundleResult.map(br => path.basename(br.fileName));
+        rewriteImports(cachedFiles, fedOptions.federationCache.cachePath);
     }
     catch (e) {
-        logger_1.logger.error('Error bundling shared npm package ');
+        logger.error('Error bundling shared npm package ');
         if (e instanceof Error) {
-            logger_1.logger.error(e.message);
+            logger.error(e.message);
         }
-        logger_1.logger.error('For more information, run in verbose mode');
-        logger_1.logger.notice('');
-        logger_1.logger.notice('');
-        logger_1.logger.notice('** Important Information: ***');
-        logger_1.logger.notice('The error message above shows an issue with bundling a node_module.');
-        logger_1.logger.notice('In most cases this is because you (indirectly) shared a Node.js package,');
-        logger_1.logger.notice('while Native Federation builds for the browser.');
-        logger_1.logger.notice('You can move such packages into devDependencies or skip them in your federation.config.js.');
-        logger_1.logger.notice('');
-        logger_1.logger.notice('More Details: https://bit.ly/nf-issue');
-        logger_1.logger.notice('');
-        logger_1.logger.notice('');
-        logger_1.logger.verbose(e);
+        logger.error('For more information, run in verbose mode');
+        logger.notice('');
+        logger.notice('');
+        logger.notice('** Important Information: ***');
+        logger.notice('The error message above shows an issue with bundling a node_module.');
+        logger.notice('In most cases this is because you (indirectly) shared a Node.js package,');
+        logger.notice('while Native Federation builds for the browser.');
+        logger.notice('You can move such packages into devDependencies or skip them in your federation.config.js.');
+        logger.notice('');
+        logger.notice('More Details: https://bit.ly/nf-issue');
+        logger.notice('');
+        logger.notice('');
+        logger.verbose(e);
         throw e;
     }
     const outFileNames = [...expectedResults];
     const result = buildResult(packageInfos, sharedBundles, outFileNames);
-    // TODO: Decide whether/when to add .map files
-    const chunks = bundleResult.filter((br) => !br.fileName.endsWith('.map') &&
-        !result.find((r) => r.outFileName === path.basename(br.fileName)));
-    addChunksToResult(chunks, result, fedOptions.dev);
+    const chunks = bundleResult.filter(br => !br.fileName.endsWith('.map') &&
+        !result.find(r => r.outFileName === path.basename(br.fileName)));
+    /**
+     * Chunking
+     */
+    let exportedChunks = undefined;
+    if (buildOptions.chunks && config.features.denseChunking) {
+        result.forEach(external => {
+            external.bundle = buildOptions.bundleName;
+        });
+        if (chunks.length > 0) {
+            exportedChunks = { [buildOptions.bundleName]: getChunkFileNames(chunks) };
+        }
+    }
+    else {
+        addChunksToResult(chunks, result);
+    }
     bundleCache.persist({
         checksum,
         externals: result,
-        files: bundleResult.map((r) => r.fileName.split(path.sep).pop() ?? r.fileName),
+        files: bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName),
+        chunks: exportedChunks,
     });
     bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-    return result;
+    return { externals: result, chunks: exportedChunks };
 }
 function rewriteImports(cachedFiles, cachePath) {
-    const newSourceFiles = cachedFiles.filter((cf) => (0, rewrite_chunk_imports_1.isSourceFile)(cf));
+    const newSourceFiles = cachedFiles.filter(cf => isSourceFile(cf));
     for (const sourceFile of newSourceFiles) {
         const sourceFilePath = path.join(cachePath, sourceFile);
-        (0, rewrite_chunk_imports_1.rewriteChunkImports)(sourceFilePath);
+        rewriteChunkImports(sourceFilePath);
     }
 }
 function createOutName(pi, configState, fedOptions, encName) {
     const hashBase = pi.version + '_' + pi.entryPoint + '_' + configState;
     const hash = calcHash(hashBase);
-    const outName = fedOptions.dev
-        ? `${encName}.${hash}-dev.js`
-        : `${encName}.${hash}.js`;
+    const outName = fedOptions.dev ? `${encName}.${hash}-dev.js` : `${encName}.${hash}.js`;
     return outName;
 }
 function buildResult(packageInfos, sharedBundles, outFileNames) {
-    return packageInfos.map((pi) => {
+    return packageInfos.map(pi => {
         const shared = sharedBundles[pi.packageName];
         return {
             packageName: pi.packageName,
             outFileName: path.basename(outFileNames.shift() || ''),
-            requiredVersion: shared.requiredVersion,
-            singleton: shared.singleton,
-            strictVersion: shared.strictVersion,
+            requiredVersion: shared?.requiredVersion,
+            singleton: shared?.singleton,
+            strictVersion: shared?.strictVersion,
             version: pi.version,
+            ...(shared?.shareScope && { shareScope: shared.shareScope }),
             // TODO: Decide whether/when we need debug infos
             // dev: !fedOptions.dev
             //   ? undefined
@@ -139,7 +153,10 @@ function buildResult(packageInfos, sharedBundles, outFileNames) {
         };
     });
 }
-function addChunksToResult(chunks, result, dev) {
+function getChunkFileNames(chunks) {
+    return chunks.map(chunk => path.basename(chunk.fileName));
+}
+function addChunksToResult(chunks, result) {
     for (const item of chunks) {
         const fileName = path.basename(item.fileName);
         result.push({
@@ -155,7 +172,7 @@ function addChunksToResult(chunks, result, dev) {
             // take care of singleton and strictVersion.
             version: '0.0.0',
             requiredVersion: '0.0.0',
-            packageName: (0, rewrite_chunk_imports_1.deriveInternalName)(fileName),
+            packageName: toChunkImport(fileName),
             outFileName: fileName,
             // dev: dev
             //   ? undefined
@@ -166,7 +183,7 @@ function addChunksToResult(chunks, result, dev) {
     }
 }
 function calcHash(hashBase) {
-    const hash = crypto_1.default
+    const hash = crypto
         .createHash('sha256')
         .update(hashBase)
         .digest('base64')
@@ -176,4 +193,3 @@ function calcHash(hashBase) {
         .substring(0, 10);
     return hash;
 }
-//# sourceMappingURL=bundle-shared.js.map

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EXTERNAL_LIST = void 0;
 const NODE_PACKAGES = [
     'assert',
     'buffer',
@@ -29,8 +26,4 @@ const NODE_PACKAGES = [
     'vm',
     'zlib',
 ];
-exports.DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap((p) => [
-    p,
-    'node:' + p,
-]);
-//# sourceMappingURL=default-external-list.js.map
+export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap(p => [p, 'node:' + p]);

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

@@ -1,16 +1,21 @@
-import { FederationInfo } from '@softarc/native-federation-runtime';
-import { NormalizedFederationConfig } from '../config/federation-config';
-import { BuildAdapter } from './build-adapter';
-import { FederationOptions } from './federation-options';
+import type { FederationInfo } 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';
+import type { NFBuildAdapter } from '../domain/core/build-adapter.contract.js';
 export interface BuildHelperParams {
     options: FederationOptions;
-    adapter: BuildAdapter;
+    adapter: NFBuildAdapter;
 }
 declare function init(params: BuildHelperParams): Promise<void>;
-declare function build(buildParams?: import("./build-for-federation").BuildParams): 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,31 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.federationBuilder = void 0;
-const configuration_context_1 = require("../config/configuration-context");
-const build_adapter_1 = require("./build-adapter");
-const build_for_federation_1 = require("./build-for-federation");
-const get_externals_1 = require("./get-externals");
-const load_federation_config_1 = require("./load-federation-config");
+import { getConfigContext, usePackageJson, useWorkspace } from '../config/configuration-context.js';
+import { getBuildAdapter, setBuildAdapter } from './build-adapter.js';
+import { buildForFederation } from './build-for-federation.js';
+import { getExternals } from './get-externals.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) {
-    (0, build_adapter_1.setBuildAdapter)(params.adapter);
-    fedOptions = params.options;
-    (0, configuration_context_1.useWorkspace)(params.options.workspaceRoot);
-    (0, configuration_context_1.usePackageJson)(params.options.packageJson);
-    config = await (0, load_federation_config_1.loadFederationConfig)(fedOptions);
-    params.options.workspaceRoot =
-        (0, configuration_context_1.getConfigContext)().workspaceRoot ?? params.options.workspaceRoot;
-    externals = (0, get_externals_1.getExternals)(config);
+    setBuildAdapter(params.adapter);
+    useWorkspace(params.options.workspaceRoot);
+    usePackageJson(params.options.packageJson);
+    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(buildParams = build_for_federation_1.defaultBuildParams) {
-    fedInfo = await (0, build_for_federation_1.buildForFederation)(config, fedOptions, externals, buildParams);
+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);
+    }
 }
-exports.federationBuilder = {
+async function close() {
+    return getBuildAdapter().dispose();
+}
+export const federationBuilder = {
     init,
     build,
+    close,
     get federationInfo() {
         return fedInfo;
     },
@@ -36,4 +43,3 @@ exports.federationBuilder = {
         return config;
     },
 };
-//# sourceMappingURL=federation-builder.js.map

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/get-externals.d.ts

@@ -1,2 +1,2 @@
-import { NormalizedFederationConfig } from '../config/federation-config';
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 export declare function getExternals(config: NormalizedFederationConfig): string[];

package/src/lib/core/get-externals.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExternals = getExternals;
-function getExternals(config) {
+export function getExternals(config) {
     const shared = Object.keys(config.shared);
-    const sharedMappings = config.sharedMappings.map((m) => m.key);
+    const sharedMappings = Object.values(config.sharedMappings);
     const externals = [...shared, ...sharedMappings, ...config.externals];
     return externals;
 }
-//# sourceMappingURL=get-externals.js.map