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

package/dist/federation-builder.cjs.js

@@ -1,741 +0,0 @@
-'use strict';
-
-var npmlog = require('npmlog');
-var path = require('path');
-var fs = require('fs');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
-var npmlog__default = /*#__PURE__*/_interopDefaultLegacy(npmlog);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-
-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$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);
-}
-function writeImportMap(sharedInfo, fedOption) {
-    const imports = sharedInfo.reduce((acc, cur)=>{
-        return _extends$2({}, 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 bundle(options) {
-    const adapter = await getBuildAdapter();
-    return await adapter(options);
-}
-
-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$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);
-}
-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$1({}, 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 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;
-}
-
-function getExternals(config) {
-    const shared = Object.keys(config.shared);
-    const sharedMappings = config.sharedMappings.map((m)=>m.key);
-    const remotes = config.remotes;
-    Object.keys(remotes).reduce((acc, key)=>{
-        if (!key) return acc;
-        acc.push(key);
-        acc.push(key + '/*');
-        return acc;
-    }, []);
-    const externals = [
-        ...shared,
-        ...sharedMappings
-    ];
-    return externals;
-}
-
-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;
-}
-
-function _extends() {
-    _extends = 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.apply(this, arguments);
-}
-let _context = {};
-function useWorkspace(workspaceRoot) {
-    _context = _extends({}, _context, {
-        workspaceRoot
-    });
-}
-function usePackageJson(packageJson) {
-    _context = _extends({}, _context, {
-        packageJson
-    });
-}
-function getConfigContext() {
-    return _context;
-}
-
-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;
-    }
-};
-
-exports.buildForFederation = buildForFederation;
-exports.bundleExposedAndMappings = bundleExposedAndMappings;
-exports.createBuildResultMap = createBuildResultMap;
-exports.defaultBuildParams = defaultBuildParams;
-exports.describeExposed = describeExposed;
-exports.describeSharedMappings = describeSharedMappings;
-exports.federationBuilder = federationBuilder;
-exports.findDepPackageJson = findDepPackageJson;
-exports.getBuildAdapter = getBuildAdapter;
-exports.getConfigContext = getConfigContext;
-exports.getExternals = getExternals;
-exports.getVersionMaps = getVersionMaps;
-exports.loadFederationConfig = loadFederationConfig;
-exports.logger = logger;
-exports.lookupInResultMap = lookupInResultMap;
-exports.setBuildAdapter = setBuildAdapter;
-exports.setLogLevel = setLogLevel;
-exports.writeFederationInfo = writeFederationInfo;
-exports.writeImportMap = writeImportMap;