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

package/dist/build.cjs.js

@@ -2,13 +2,13 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var federationBuilder = require('./federation-builder.cjs.js');
+var npmlog = require('npmlog');
 var path = require('path');
 var fs = require('fs');
+var getExternals = require('./get-externals.cjs.js');
 var process = require('process');
 var JSON5 = require('json5');
 var crypto = require('crypto');
-require('npmlog');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -30,14 +30,105 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+var npmlog__default = /*#__PURE__*/_interopDefaultLegacy(npmlog);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var process__default = /*#__PURE__*/_interopDefaultLegacy(process);
 var JSON5__namespace = /*#__PURE__*/_interopNamespace(JSON5);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 
+const levels = npmlog__default["default"].levels;
+npmlog__default["default"].addLevel('error', levels.error, {
+    fg: 'brightWhite',
+    bg: 'red'
+}, ' ERR! ');
+npmlog__default["default"].addLevel('warn', levels.info, {
+    fg: 'brightWhite',
+    bg: 'yellow'
+}, ' WARN ');
+npmlog__default["default"].addLevel('info', levels.warn, {
+    fg: 'brightWhite',
+    bg: 'green'
+}, ' INFO ');
+npmlog__default["default"].addLevel('notice', levels.notice, {
+    fg: 'black',
+    bg: 'brightYellow'
+}, ' NOTE ');
+npmlog__default["default"].addLevel('verbose', levels.verbose, {
+    fg: 'brightWhite',
+    bg: 'brightBlue'
+}, ' VRB! ');
+npmlog__default["default"].addLevel('silly', levels.silly, {
+    fg: 'black',
+    bg: 'white'
+}, ' DBG! ');
+const logger = {
+    error: (msg)=>npmlog__default["default"].error('', msg),
+    warn: (msg)=>npmlog__default["default"].warn('', msg),
+    notice: (msg)=>npmlog__default["default"].notice('', msg),
+    info: (msg)=>npmlog__default["default"].info('', msg),
+    verbose: (msg)=>npmlog__default["default"].verbose('', msg),
+    debug: (msg)=>npmlog__default["default"].silly('', msg)
+};
+const setLogLevel = (level)=>{
+    npmlog__default["default"].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__namespace.join(fedOption.workspaceRoot, fedOption.outputPath, 'importmap.json');
+    fs__namespace.writeFileSync(importMapPath, JSON.stringify(importMap, null, 2));
+}
+
+function writeFederationInfo(federationInfo, fedOptions) {
+    const metaDataPath = path__namespace.join(fedOptions.workspaceRoot, fedOptions.outputPath, 'remoteEntry.json');
+    fs__namespace.writeFileSync(metaDataPath, JSON.stringify(federationInfo, null, 2));
+}
+
+async function loadFederationConfig(fedOptions) {
+    const fullConfigPath = path__namespace.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
+    if (!fs__namespace.existsSync(fullConfigPath)) {
+        throw new Error('Expected ' + fullConfigPath);
+    }
+    const config = await (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(`${fullConfigPath}`);
+    return config;
+}
+
 const DEFAULT_SKIP_LIST = [
     '@module-federation/native-federation-runtime',
     '@module-federation/native-federation',
@@ -82,6 +173,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__namespace.join(f, 'package.json')).filter((f)=>fs__namespace.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__namespace} needs to be a parent of the project folder ${child}`);
+    }
+    let current = child;
+    while(current !== parent){
+        result.push(current);
+        const cand = normalize(path__namespace.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__namespace.readFileSync(f, 'utf-8'));
+        const directory = normalize(path__namespace.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__namespace.join(projectRoot, 'node_modules', mainPkgName);
+    let mainPkgJsonPath = path__namespace.join(mainPkgPath, 'package.json');
+    let directory = projectRoot;
+    while(path__namespace.dirname(directory) !== directory){
+        if (fs__namespace.existsSync(mainPkgJsonPath)) {
+            break;
+        }
+        directory = normalize(path__namespace.dirname(directory), true);
+        mainPkgPath = path__namespace.join(directory, 'node_modules', mainPkgName);
+        mainPkgJsonPath = path__namespace.join(mainPkgPath, 'package.json');
+    }
+    if (!fs__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = mainPkgJson['module'];
+    if (cand && relSecondaryPath === '.') {
+        return {
+            entryPoint: path__namespace.join(mainPkgPath, cand),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    const secondaryPgkPath = path__namespace.join(mainPkgPath, relSecondaryPath);
+    const secondaryPgkJsonPath = path__namespace.join(secondaryPgkPath, 'package.json');
+    let secondaryPgkJson = null;
+    if (fs__namespace.existsSync(secondaryPgkJsonPath)) {
+        secondaryPgkJson = readJson(secondaryPgkJsonPath);
+    }
+    if (secondaryPgkJson && secondaryPgkJson.module) {
+        return {
+            entryPoint: path__namespace.join(secondaryPgkPath, secondaryPgkJson.module),
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    cand = path__namespace.join(secondaryPgkPath, 'index.mjs');
+    if (fs__namespace.existsSync(cand)) {
+        return {
+            entryPoint: cand,
+            packageName,
+            version,
+            esm: true
+        };
+    }
+    if (secondaryPgkJson && secondaryPgkJson.main) {
+        return {
+            entryPoint: path__namespace.join(secondaryPgkPath, secondaryPgkJson.main),
+            packageName,
+            version,
+            esm
+        };
+    }
+    cand = path__namespace.join(secondaryPgkPath, 'index.js');
+    if (fs__namespace.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__namespace.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',
@@ -110,7 +502,7 @@ function findPackageJson(folder) {
     throw new Error('no package.json found. Searched the following folder and all parents: ' + folder);
 }
 function lookupVersion(key, workspaceRoot) {
-    const versionMaps = federationBuilder.getVersionMaps(workspaceRoot, workspaceRoot);
+    const versionMaps = getVersionMaps(workspaceRoot, workspaceRoot);
     for (const versionMap of versionMaps){
         const version = lookupVersionInMap(key, versionMap);
         if (version) {
@@ -232,7 +624,7 @@ function shareAll(config = {}, skip = DEFAULT_SKIP_LIST, projectPath = '') {
     // if (!workspacePath) {
     //   workspacePath = projectPath;
     // }
-    const versionMaps = federationBuilder.getVersionMaps(projectPath, projectPath);
+    const versionMaps = getVersionMaps(projectPath, projectPath);
     const share = {};
     for (const versions of versionMaps){
         const preparedSkipList = prepareSkipList(skip);
@@ -252,11 +644,11 @@ function shareAll(config = {}, skip = DEFAULT_SKIP_LIST, projectPath = '') {
     return module.exports.share(share, projectPath);
 }
 function inferProjectPath(projectPath) {
-    if (!projectPath && federationBuilder.getConfigContext().packageJson) {
-        projectPath = path__default["default"].dirname(federationBuilder.getConfigContext().packageJson || '');
+    if (!projectPath && getConfigContext().packageJson) {
+        projectPath = path__default["default"].dirname(getConfigContext().packageJson || '');
     }
-    if (!projectPath && federationBuilder.getConfigContext().workspaceRoot) {
-        projectPath = federationBuilder.getConfigContext().workspaceRoot || '';
+    if (!projectPath && getConfigContext().workspaceRoot) {
+        projectPath = getConfigContext().workspaceRoot || '';
     }
     if (!projectPath) {
         projectPath = process__default["default"].cwd();
@@ -289,9 +681,9 @@ function share(shareObjects, projectPath = '') {
         }
         result[key] = shareObject;
         if (includeSecondaries) {
-            const libPackageJson = federationBuilder.findDepPackageJson(key, path__default["default"].dirname(packagePath));
+            const libPackageJson = findDepPackageJson(key, path__default["default"].dirname(packagePath));
             if (!libPackageJson) {
-                federationBuilder.logger.error('Could not find folder containing dep ' + key);
+                logger.error('Could not find folder containing dep ' + key);
                 continue;
             }
             const libPath = path__default["default"].dirname(libPackageJson);
@@ -404,10 +796,293 @@ function normalizeSharedMappings(config, skip) {
     });
     const result = paths.filter((p)=>!isInSkipList(p.key, skip) && !p.key.includes('*'));
     if (paths.find((p)=>p.key.includes('*'))) {
-        federationBuilder.logger.warn('Sharing mapped paths with wildcards (*) not supported');
+        logger.warn('Sharing mapped paths with wildcards (*) not supported');
+    }
+    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__namespace.existsSync(mapSrc)) {
+        fs__namespace.copyFileSync(mapSrc, mapDest);
+    }
+}
+
+async function bundleShared(config, fedOptions, externals) {
+    const folder = fedOptions.packageJson ? path__namespace.dirname(fedOptions.packageJson) : fedOptions.workspaceRoot;
+    const cachePath = path__namespace.join(fedOptions.workspaceRoot, 'node_modules/.cache/native-federation');
+    fs__namespace.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__namespace.join(fedOptions.workspaceRoot, fedOptions.outputPath);
+    const exptedResults = allEntryPoints.map((ep)=>path__namespace.join(fullOutputPath, ep.outName));
+    const entryPoints = allEntryPoints.filter((ep)=>!fs__namespace.existsSync(path__namespace.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__namespace.basename(fileName);
+            const cachedFile = path__namespace.join(cachePath, outFileName);
+            const realoutFileName = 'mf_' + path__namespace.basename(fileName);
+            const realcachedFile = path__namespace.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__namespace.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__namespace.mkdirSync(path__namespace.dirname(fullOutputPath), {
+        recursive: true
+    });
+    if (fs__namespace.existsSync(cachedFile)) {
+        fs__namespace.copyFileSync(cachedFile, fullOutputPath);
+    }
+}
+
+function createBuildResultMap(buildResult, isHashed) {
+    const map = {};
+    for (const item of buildResult){
+        const resultName = path__default["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["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["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["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["default"].normalize(path__default["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["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.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__namespace.readFileSync(fileName);
@@ -416,36 +1091,36 @@ function hashFile(fileName) {
     return hashSum.digest('hex');
 }
 
-exports.buildForFederation = federationBuilder.buildForFederation;
-exports.bundleExposedAndMappings = federationBuilder.bundleExposedAndMappings;
-exports.createBuildResultMap = federationBuilder.createBuildResultMap;
-exports.defaultBuildParams = federationBuilder.defaultBuildParams;
-exports.describeExposed = federationBuilder.describeExposed;
-exports.describeSharedMappings = federationBuilder.describeSharedMappings;
-exports.federationBuilder = federationBuilder.federationBuilder;
-exports.getBuildAdapter = federationBuilder.getBuildAdapter;
-exports.getExternals = federationBuilder.getExternals;
-exports.loadFederationConfig = federationBuilder.loadFederationConfig;
-exports.logger = federationBuilder.logger;
-exports.lookupInResultMap = federationBuilder.lookupInResultMap;
-exports.setBuildAdapter = federationBuilder.setBuildAdapter;
-exports.setLogLevel = federationBuilder.setLogLevel;
-exports.writeFederationInfo = federationBuilder.writeFederationInfo;
-exports.writeImportMap = federationBuilder.writeImportMap;
+exports.getExternals = getExternals.getExternals;
 exports.DEFAULT_SECONARIES_SKIP_LIST = DEFAULT_SECONARIES_SKIP_LIST;
 exports._findSecondaries = _findSecondaries;
 exports.addSecondaries = addSecondaries;
+exports.buildForFederation = buildForFederation;
+exports.bundleExposedAndMappings = bundleExposedAndMappings;
+exports.createBuildResultMap = createBuildResultMap;
+exports.defaultBuildParams = defaultBuildParams;
+exports.describeExposed = describeExposed;
+exports.describeSharedMappings = describeSharedMappings;
+exports.federationBuilder = federationBuilder;
 exports.findPackageJson = findPackageJson;
 exports.findRootTsConfigJson = findRootTsConfigJson;
 exports.findSecondaries = findSecondaries;
+exports.getBuildAdapter = getBuildAdapter;
 exports.getDefaultEntry = getDefaultEntry;
 exports.getSecondaries = getSecondaries;
 exports.hashFile = hashFile;
 exports.inferProjectPath = inferProjectPath;
+exports.loadFederationConfig = loadFederationConfig;
+exports.logger = logger;
+exports.lookupInResultMap = lookupInResultMap;
 exports.lookupVersion = lookupVersion;
 exports.lookupVersionInMap = lookupVersionInMap;
 exports.readConfiguredSecondaries = readConfiguredSecondaries;
+exports.setBuildAdapter = setBuildAdapter;
 exports.setInferVersion = setInferVersion;
+exports.setLogLevel = setLogLevel;
 exports.share = share;
 exports.shareAll = shareAll;
 exports.withFederation = withFederation;
+exports.writeFederationInfo = writeFederationInfo;
+exports.writeImportMap = writeImportMap;