@module-federation/esbuild 0.0.0-next-20240524225331 → 0.0.0-next-20240528203231

package/dist/build.esm.js

@@ -1,13 +1,103 @@
-import { g as getVersionMaps, a as getConfigContext, b as findDepPackageJson, l as logger } from './federation-builder.esm.js';
-export { j as buildForFederation, k as bundleExposedAndMappings, p as createBuildResultMap, i as defaultBuildParams, m as describeExposed, n as describeSharedMappings, f as federationBuilder, c as getBuildAdapter, e as getExternals, h as loadFederationConfig, l as logger, q as lookupInResultMap, s as setBuildAdapter, o as setLogLevel, d as writeFederationInfo, w as writeImportMap } from './federation-builder.esm.js';
+import npmlog from 'npmlog';
 import * as path from 'path';
 import path__default from 'path';
 import * as fs from 'fs';
 import fs__default from 'fs';
+import { g as getExternals } from './get-externals.esm.js';
+export { g as getExternals } from './get-externals.esm.js';
 import process from 'process';
 import * as JSON5 from 'json5';
 import * as crypto from 'crypto';
-import 'npmlog';
+
+const levels = npmlog.levels;
+npmlog.addLevel('error', levels.error, {
+    fg: 'brightWhite',
+    bg: 'red'
+}, ' ERR! ');
+npmlog.addLevel('warn', levels.info, {
+    fg: 'brightWhite',
+    bg: 'yellow'
+}, ' WARN ');
+npmlog.addLevel('info', levels.warn, {
+    fg: 'brightWhite',
+    bg: 'green'
+}, ' INFO ');
+npmlog.addLevel('notice', levels.notice, {
+    fg: 'black',
+    bg: 'brightYellow'
+}, ' NOTE ');
+npmlog.addLevel('verbose', levels.verbose, {
+    fg: 'brightWhite',
+    bg: 'brightBlue'
+}, ' VRB! ');
+npmlog.addLevel('silly', levels.silly, {
+    fg: 'black',
+    bg: 'white'
+}, ' DBG! ');
+const logger = {
+    error: (msg)=>npmlog.error('', msg),
+    warn: (msg)=>npmlog.warn('', msg),
+    notice: (msg)=>npmlog.notice('', msg),
+    info: (msg)=>npmlog.info('', msg),
+    verbose: (msg)=>npmlog.verbose('', msg),
+    debug: (msg)=>npmlog.silly('', msg)
+};
+const setLogLevel = (level)=>{
+    npmlog.level = level === 'debug' ? 'silly' : level;
+};
+setLogLevel('info');
+
+let _buildAdapter = async ()=>{
+    logger.error('Please set a BuildAdapter!');
+    return [];
+};
+function setBuildAdapter(buildAdapter) {
+    _buildAdapter = buildAdapter;
+}
+function getBuildAdapter() {
+    return _buildAdapter;
+}
+
+function _extends$3() {
+    _extends$3 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$3.apply(this, arguments);
+}
+function writeImportMap(sharedInfo, fedOption) {
+    const imports = sharedInfo.reduce((acc, cur)=>{
+        return _extends$3({}, acc, {
+            [cur.packageName]: cur.outFileName
+        });
+    }, {});
+    const importMap = {
+        imports
+    };
+    const importMapPath = path.join(fedOption.workspaceRoot, fedOption.outputPath, 'importmap.json');
+    fs.writeFileSync(importMapPath, JSON.stringify(importMap, null, 2));
+}
+
+function writeFederationInfo(federationInfo, fedOptions) {
+    const metaDataPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath, 'remoteEntry.json');
+    fs.writeFileSync(metaDataPath, JSON.stringify(federationInfo, null, 2));
+}
+
+async function loadFederationConfig(fedOptions) {
+    const fullConfigPath = path.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
+    if (!fs.existsSync(fullConfigPath)) {
+        throw new Error('Expected ' + fullConfigPath);
+    }
+    const config = await import(`${fullConfigPath}`);
+    return config;
+}
 
 const DEFAULT_SKIP_LIST = [
     '@module-federation/native-federation-runtime',
@@ -53,6 +143,307 @@ function isInSkipList(entry, skipList) {
     return false;
 }
 
+function normalize(path, trailingSlash) {
+    let cand = path.replace(/\\/g, '/');
+    if (typeof trailingSlash === 'undefined') {
+        return cand;
+    }
+    while(cand.endsWith('/')){
+        cand = cand.substring(0, cand.length - 1);
+    }
+    if (trailingSlash) {
+        return cand + '/';
+    }
+    return cand;
+}
+
+function _extends$2() {
+    _extends$2 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$2.apply(this, arguments);
+}
+const packageCache = {};
+function findPackageJsonFiles(project, workspace) {
+    return expandFolders(project, workspace).map((f)=>path.join(f, 'package.json')).filter((f)=>fs.existsSync(f));
+}
+function expandFolders(child, parent) {
+    const result = [];
+    parent = normalize(parent, true);
+    child = normalize(child, true);
+    if (!child.startsWith(parent)) {
+        throw new Error(`Workspace folder ${path} needs to be a parent of the project folder ${child}`);
+    }
+    let current = child;
+    while(current !== parent){
+        result.push(current);
+        const cand = normalize(path.dirname(current), true);
+        if (cand === current) {
+            break;
+        }
+        current = cand;
+    }
+    result.push(parent);
+    return result;
+}
+function getPackageInfo(packageName, workspaceRoot) {
+    workspaceRoot = normalize(workspaceRoot, true);
+    const packageJsonInfos = getPackageJsonFiles(workspaceRoot, workspaceRoot);
+    for (const info of packageJsonInfos){
+        const cand = _getPackageInfo(packageName, info.directory);
+        if (cand) {
+            return cand;
+        }
+    }
+    logger.warn('No meta data found for shared lib ' + packageName);
+    return null;
+}
+function getVersionMapCacheKey(project, workspace) {
+    return `${project}**${workspace}`;
+}
+function getVersionMaps(project, workspace) {
+    return getPackageJsonFiles(project, workspace).map((json)=>_extends$2({}, json.content['dependencies']));
+}
+function getPackageJsonFiles(project, workspace) {
+    const cacheKey = getVersionMapCacheKey(project, workspace);
+    let maps = packageCache[cacheKey];
+    if (maps) {
+        return maps;
+    }
+    maps = findPackageJsonFiles(project, workspace).map((f)=>{
+        const content = JSON.parse(fs.readFileSync(f, 'utf-8'));
+        const directory = normalize(path.dirname(f), true);
+        const result = {
+            content,
+            directory
+        };
+        return result;
+    });
+    packageCache[cacheKey] = maps;
+    return maps;
+}
+function findDepPackageJson(packageName, projectRoot) {
+    const mainPkgName = getPkgFolder(packageName);
+    let mainPkgPath = path.join(projectRoot, 'node_modules', mainPkgName);
+    let mainPkgJsonPath = path.join(mainPkgPath, 'package.json');
+    let directory = projectRoot;
+    while(path.dirname(directory) !== directory){
+        if (fs.existsSync(mainPkgJsonPath)) {
+            break;
+        }
+        directory = normalize(path.dirname(directory), true);
+        mainPkgPath = path.join(directory, 'node_modules', mainPkgName);
+        mainPkgJsonPath = path.join(mainPkgPath, 'package.json');
+    }
+    if (!fs.existsSync(mainPkgJsonPath)) {
+        logger.verbose('No package.json found for ' + packageName + ' in ' + mainPkgPath);
+        return null;
+    }
+    return mainPkgJsonPath;
+}
+function _getPackageInfo(packageName, directory) {
+    var _mainPkgJson_exports, _mainPkgJson_exports_relSecondaryPath, _mainPkgJson_exports1, _mainPkgJson_exports_relSecondaryPath1, _mainPkgJson_exports2, _mainPkgJson_exports_relSecondaryPath2, _mainPkgJson_exports3;
+    const mainPkgName = getPkgFolder(packageName);
+    const mainPkgJsonPath = findDepPackageJson(packageName, directory);
+    if (!mainPkgJsonPath) {
+        return null;
+    }
+    const mainPkgPath = path.dirname(mainPkgJsonPath);
+    const mainPkgJson = readJson(mainPkgJsonPath);
+    const version = mainPkgJson['version'];
+    const esm = mainPkgJson['type'] === 'module';
+    if (!version) {
+        logger.warn('No version found for ' + packageName);
+        return null;
+    }
+    let relSecondaryPath = path.relative(mainPkgName, packageName);
+    if (!relSecondaryPath) {
+        relSecondaryPath = '.';
+    } else {
+        relSecondaryPath = './' + relSecondaryPath.replace(/\\/g, '/');
+    }
+    let cand = mainPkgJson == null ? void 0 : (_mainPkgJson_exports = mainPkgJson.exports) == null ? void 0 : _mainPkgJson_exports[relSecondaryPath];
+    if (typeof cand === 'string') {
+        return {
+            entryPoint: path.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson == null ? void 0 : (_mainPkgJson_exports1 = mainPkgJson.exports) == null ? void 0 : (_mainPkgJson_exports_relSecondaryPath = _mainPkgJson_exports1[relSecondaryPath]) == null ? void 0 : _mainPkgJson_exports_relSecondaryPath.import;
+    if (typeof cand === 'object') {
+        if (cand.module) {
+            cand = cand.module;
+        } else if (cand.import) {
+            cand = cand.import;
+        } else if (cand.default) {
+            cand = cand.default;
+        } else {
+            cand = null;
+        }
+    }
+    if (cand) {
+        if (typeof cand === 'object') {
+            if (cand.module) {
+                cand = cand.module;
+            } else if (cand.import) {
+                cand = cand.import;
+            } else if (cand.default) {
+                cand = cand.default;
+            } else {
+                cand = null;
+            }
+        }
+        return {
+            entryPoint: path.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson == null ? void 0 : (_mainPkgJson_exports2 = mainPkgJson.exports) == null ? void 0 : (_mainPkgJson_exports_relSecondaryPath1 = _mainPkgJson_exports2[relSecondaryPath]) == null ? void 0 : _mainPkgJson_exports_relSecondaryPath1.module;
+    if (typeof cand === 'object') {
+        if (cand.module) {
+            cand = cand.module;
+        } else if (cand.import) {
+            cand = cand.import;
+        } else if (cand.default) {
+            cand = cand.default;
+        } else {
+            cand = null;
+        }
+    }
+    if (cand) {
+        return {
+            entryPoint: path.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson == null ? void 0 : (_mainPkgJson_exports3 = mainPkgJson.exports) == null ? void 0 : (_mainPkgJson_exports_relSecondaryPath2 = _mainPkgJson_exports3[relSecondaryPath]) == null ? void 0 : _mainPkgJson_exports_relSecondaryPath2.default;
+    if (cand) {
+        if (typeof cand === 'object') {
+            if (cand.module) {
+                cand = cand.module;
+            } else if (cand.import) {
+                cand = cand.import;
+            } else if (cand.default) {
+                cand = cand.default;
+            } else {
+                cand = null;
+            }
+        }
+        return {
+            entryPoint: path.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson['module'];
+    if (cand && relSecondaryPath === '.') {
+        return {
+            entryPoint: path.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    const secondaryPgkPath = path.join(mainPkgPath, relSecondaryPath);
+    const secondaryPgkJsonPath = path.join(secondaryPgkPath, 'package.json');
+    let secondaryPgkJson = null;
+    if (fs.existsSync(secondaryPgkJsonPath)) {
+        secondaryPgkJson = readJson(secondaryPgkJsonPath);
+    }
+    if (secondaryPgkJson && secondaryPgkJson.module) {
+        return {
+            entryPoint: path.join(secondaryPgkPath, secondaryPgkJson.module),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    cand = path.join(secondaryPgkPath, 'index.mjs');
+    if (fs.existsSync(cand)) {
+        return {
+            entryPoint: cand,
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    if (secondaryPgkJson && secondaryPgkJson.main) {
+        return {
+            entryPoint: path.join(secondaryPgkPath, secondaryPgkJson.main),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = path.join(secondaryPgkPath, 'index.js');
+    if (fs.existsSync(cand)) {
+        return {
+            entryPoint: cand,
+            packageName,
+            version,
+            esm
+        };
+    }
+    logger.warn('No entry point found for ' + packageName);
+    logger.warn("If you don't need this package, skip it in your federation.config.js or consider moving it into depDependencies in your package.json");
+    return null;
+}
+function readJson(mainPkgJsonPath) {
+    return JSON.parse(fs.readFileSync(mainPkgJsonPath, 'utf-8'));
+}
+function getPkgFolder(packageName) {
+    const parts = packageName.split('/');
+    let folder = parts[0];
+    if (folder.startsWith('@')) {
+        folder += '/' + parts[1];
+    }
+    return folder;
+}
+
+function _extends$1() {
+    _extends$1 = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends$1.apply(this, arguments);
+}
+let _context = {};
+function useWorkspace(workspaceRoot) {
+    _context = _extends$1({}, _context, {
+        workspaceRoot
+    });
+}
+function usePackageJson(packageJson) {
+    _context = _extends$1({}, _context, {
+        packageJson
+    });
+}
+function getConfigContext() {
+    return _context;
+}
+
 let inferVersion = false;
 const DEFAULT_SECONARIES_SKIP_LIST = [
     '@angular/router/upgrade',
@@ -380,6 +771,289 @@ function normalizeSharedMappings(config, skip) {
     return result;
 }
 
+async function bundle(options) {
+    const adapter = await getBuildAdapter();
+    return await adapter(options);
+}
+
+function copySrcMapIfExists(cachedFile, fullOutputPath) {
+    const mapSrc = cachedFile + '.map';
+    const mapDest = fullOutputPath + '.map';
+    if (fs.existsSync(mapSrc)) {
+        fs.copyFileSync(mapSrc, mapDest);
+    }
+}
+
+async function bundleShared(config, fedOptions, externals) {
+    const folder = fedOptions.packageJson ? path.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
+    const cachePath = path.join(fedOptions.workspaceRoot, 'node_modules/.cache/native-federation');
+    fs.mkdirSync(cachePath, {
+        recursive: true
+    });
+    const packageInfos = Object.keys(config.shared).map((packageName)=>getPackageInfo(packageName, folder)).filter((pi)=>!!pi);
+    const allEntryPoints = packageInfos.map((pi)=>{
+        const encName = pi.packageName.replace(/[^A-Za-z0-9]/g, '_');
+        const encVersion = pi.version.replace(/[^A-Za-z0-9]/g, '_');
+        const outName = fedOptions.dev ? `${encName}-${encVersion}-dev.js` : `${encName}-${encVersion}.js`;
+        return {
+            fileName: pi.entryPoint,
+            outName
+        };
+    });
+    const fullOutputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
+    const exptedResults = allEntryPoints.map((ep)=>path.join(fullOutputPath, ep.outName));
+    const entryPoints = allEntryPoints.filter((ep)=>!fs.existsSync(path.join(cachePath, ep.outName)));
+    if (entryPoints.length > 0) {
+        logger.info('Preparing shared npm packages');
+        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");
+    }
+    try {
+        const build = await bundle({
+            entryPoints,
+            tsConfigPath: fedOptions.tsConfig,
+            external: externals,
+            outdir: cachePath,
+            mappedPaths: config.sharedMappings,
+            dev: fedOptions.dev,
+            kind: 'shared-package',
+            hash: false,
+            packageInfos: packageInfos,
+            name: config.name
+        });
+        for (const fileName of exptedResults){
+            const outFileName = path.basename(fileName);
+            const cachedFile = path.join(cachePath, outFileName);
+            const realoutFileName = 'mf_' + path.basename(fileName);
+            const realcachedFile = path.join(cachePath, realoutFileName);
+            copyFileIfExists(cachedFile, fileName);
+            copySrcMapIfExists(cachedFile, fileName);
+            copyFileIfExists(realcachedFile, fileName.replace(outFileName, realoutFileName));
+            copySrcMapIfExists(realcachedFile, fileName.replace(outFileName, realoutFileName));
+        }
+    } catch (e) {
+        logger.error('Error bundling shared npm package ');
+        if (e instanceof Error) {
+            logger.error(e.message);
+        }
+        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);
+    }
+    const outFileNames = [
+        ...exptedResults
+    ];
+    return packageInfos.map((pi)=>{
+        const shared = config.shared[pi.packageName];
+        return {
+            packageName: pi.packageName,
+            outFileName: path.basename(outFileNames.shift() || ''),
+            requiredVersion: shared.requiredVersion,
+            singleton: shared.singleton,
+            strictVersion: shared.strictVersion,
+            version: pi.version,
+            dev: !fedOptions.dev ? undefined : {
+                entryPoint: normalize(pi.entryPoint)
+            }
+        };
+    });
+}
+function copyFileIfExists(cachedFile, fullOutputPath) {
+    fs.mkdirSync(path.dirname(fullOutputPath), {
+        recursive: true
+    });
+    if (fs.existsSync(cachedFile)) {
+        fs.copyFileSync(cachedFile, fullOutputPath);
+    }
+}
+
+function createBuildResultMap(buildResult, isHashed) {
+    const map = {};
+    for (const item of buildResult){
+        const resultName = path__default.basename(item.fileName);
+        let requestName = resultName;
+        if (isHashed) {
+            const start = resultName.lastIndexOf('-');
+            const end = resultName.lastIndexOf('.');
+            const part1 = resultName.substring(0, start);
+            const part2 = resultName.substring(end);
+            requestName = part1 + part2;
+        }
+        map[requestName] = resultName;
+    }
+    return map;
+}
+function lookupInResultMap(map, requestName) {
+    const key = path__default.basename(requestName);
+    return map[key];
+}
+
+async function bundleExposedAndMappings(config, fedOptions, externals) {
+    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 exposes = Object.keys(config.exposes).map((key)=>{
+        const entryPoint = config.exposes[key];
+        const outFilePath = key + '.js';
+        return {
+            fileName: entryPoint,
+            outName: outFilePath,
+            key
+        };
+    });
+    const entryPoints = [
+        ...shared,
+        ...exposes
+    ];
+    const hash = !fedOptions.dev;
+    logger.info('Building federation artefacts');
+    const 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',
+        hash
+    });
+    const resultMap = createBuildResultMap(result, hash);
+    const sharedResult = [];
+    for (const item of shared){
+        sharedResult.push({
+            packageName: item.key,
+            outFileName: lookupInResultMap(resultMap, item.outName),
+            requiredVersion: '',
+            singleton: true,
+            strictVersion: false,
+            version: '',
+            dev: !fedOptions.dev ? undefined : {
+                entryPoint: normalize(path__default.normalize(item.fileName))
+            }
+        });
+    }
+    const exposedResult = [];
+    for (const item of exposes){
+        exposedResult.push({
+            key: item.key,
+            outFileName: lookupInResultMap(resultMap, item.outName),
+            dev: !fedOptions.dev ? undefined : {
+                entryPoint: normalize(path__default.join(fedOptions.workspaceRoot, item.fileName))
+            }
+        });
+    }
+    return {
+        mappings: sharedResult,
+        exposes: exposedResult
+    };
+}
+function describeExposed(config, options) {
+    const result = [];
+    for(const key in config.exposes){
+        const localPath = normalize(path__default.normalize(path__default.join(options.workspaceRoot, config.exposes[key])));
+        result.push({
+            key,
+            outFileName: '',
+            dev: !options.dev ? undefined : {
+                entryPoint: localPath
+            }
+        });
+    }
+    return result;
+}
+function describeSharedMappings(config, fedOptions) {
+    const result = [];
+    for (const m of config.sharedMappings){
+        result.push({
+            packageName: m.key,
+            outFileName: '',
+            requiredVersion: '',
+            singleton: true,
+            strictVersion: false,
+            version: '',
+            dev: !fedOptions.dev ? undefined : {
+                entryPoint: normalize(path__default.normalize(m.path))
+            }
+        });
+    }
+    return result;
+}
+
+const defaultBuildParams = {
+    skipMappingsAndExposed: false
+};
+async function buildForFederation(config, fedOptions, externals, buildParams = defaultBuildParams) {
+    let artefactInfo;
+    if (!buildParams.skipMappingsAndExposed) {
+        artefactInfo = await bundleExposedAndMappings(config, fedOptions, externals);
+    }
+    const exposedInfo = !artefactInfo ? describeExposed(config, fedOptions) : artefactInfo.exposes;
+    const sharedPackageInfo = await bundleShared(config, fedOptions, externals);
+    const sharedMappingInfo = !artefactInfo ? describeSharedMappings(config, fedOptions) : artefactInfo.mappings;
+    const sharedInfo = [
+        ...sharedPackageInfo,
+        ...sharedMappingInfo
+    ];
+    const federationInfo = {
+        name: config.name,
+        shared: sharedInfo,
+        exposes: exposedInfo
+    };
+    writeFederationInfo(federationInfo, fedOptions);
+    writeImportMap(sharedInfo, fedOptions);
+    return federationInfo;
+}
+
+let externals = [];
+let config;
+let fedOptions;
+let fedInfo;
+async function init(params) {
+    var _getConfigContext;
+    setBuildAdapter(params.adapter);
+    fedOptions = params.options;
+    useWorkspace(params.options.workspaceRoot);
+    usePackageJson(params.options.packageJson);
+    config = await loadFederationConfig(fedOptions);
+    var _getConfigContext_workspaceRoot;
+    params.options.workspaceRoot = (_getConfigContext_workspaceRoot = (_getConfigContext = getConfigContext()) == null ? void 0 : _getConfigContext.workspaceRoot) != null ? _getConfigContext_workspaceRoot : params.options.workspaceRoot;
+    externals = getExternals(config);
+}
+async function build(buildParams = defaultBuildParams) {
+    fedInfo = await buildForFederation(config, fedOptions, externals, buildParams);
+}
+const federationBuilder = {
+    init,
+    build,
+    get federationInfo () {
+        return fedInfo;
+    },
+    get externals () {
+        return externals;
+    },
+    get config () {
+        return config;
+    }
+};
+
 function hashFile(fileName) {
     const fileBuffer = fs.readFileSync(fileName);
     const hashSum = crypto.createHash('md5');
@@ -387,4 +1061,4 @@ function hashFile(fileName) {
     return hashSum.digest('hex');
 }
 
-export { DEFAULT_SECONARIES_SKIP_LIST, _findSecondaries, addSecondaries, findPackageJson, findRootTsConfigJson, findSecondaries, getDefaultEntry, getSecondaries, hashFile, inferProjectPath, lookupVersion, lookupVersionInMap, readConfiguredSecondaries, setInferVersion, share, shareAll, withFederation };
+export { DEFAULT_SECONARIES_SKIP_LIST, _findSecondaries, addSecondaries, buildForFederation, bundleExposedAndMappings, createBuildResultMap, defaultBuildParams, describeExposed, describeSharedMappings, federationBuilder, findPackageJson, findRootTsConfigJson, findSecondaries, getBuildAdapter, getDefaultEntry, getSecondaries, hashFile, inferProjectPath, loadFederationConfig, logger, lookupInResultMap, lookupVersion, lookupVersionInMap, readConfiguredSecondaries, setBuildAdapter, setInferVersion, setLogLevel, share, shareAll, withFederation, writeFederationInfo, writeImportMap };