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

package/dist/build.cjs.js

@@ -2,13 +2,12 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var npmlog = require('npmlog');
+var getExternals = require('./get-externals.cjs.js');
 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');
+var npmlog = require('npmlog');
+require('json5');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -30,95 +29,12 @@ function _interopNamespace(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);
 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));
-}
+var npmlog__default = /*#__PURE__*/_interopDefaultLegacy(npmlog);
 
 async function loadFederationConfig(fedOptions) {
     const fullConfigPath = path__namespace.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
@@ -157,22 +73,66 @@ function prepareSkipList(skipList) {
     return {
         strings: new Set(skipList.filter((e)=>typeof e === 'string')),
         functions: skipList.filter((e)=>typeof e === 'function'),
-        regexps: skipList.filter((e)=>typeof e === 'object')
+        regexps: skipList.filter((e)=>e instanceof RegExp)
     };
 }
 function isInSkipList(entry, skipList) {
     if (skipList.strings.has(entry)) {
         return true;
     }
-    if (skipList.functions.find((f)=>f(entry))) {
+    if (skipList.functions.some((f)=>f(entry))) {
         return true;
     }
-    if (skipList.regexps.find((r)=>r.test(entry))) {
+    if (skipList.regexps.some((r)=>r.test(entry))) {
         return true;
     }
     return false;
 }
 
+let _context = {};
+function getConfigContext() {
+    return _context;
+}
+
+/* eslint-disable @typescript-eslint/no-explicit-any */ //@ts-ignore
+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');
+
 function normalize(path, trailingSlash) {
     let cand = path.replace(/\\/g, '/');
     if (typeof trailingSlash === 'undefined') {
@@ -187,8 +147,8 @@ function normalize(path, trailingSlash) {
     return cand;
 }
 
-function _extends$2() {
-    _extends$2 = Object.assign || function(target) {
+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){
@@ -199,7 +159,7 @@ function _extends$2() {
         }
         return target;
     };
-    return _extends$2.apply(this, arguments);
+    return _extends$1.apply(this, arguments);
 }
 const packageCache = {};
 function findPackageJsonFiles(project, workspace) {
@@ -210,7 +170,7 @@ function expandFolders(child, parent) {
     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}`);
+        throw new Error(`Workspace folder ${parent} needs to be a parent of the project folder ${child}`);
     }
     let current = child;
     while(current !== parent){
@@ -224,23 +184,11 @@ function expandFolders(child, parent) {
     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']));
+    return getPackageJsonFiles(project, workspace).map((json)=>_extends$1({}, json.content['dependencies']));
 }
 function getPackageJsonFiles(project, workspace) {
     const cacheKey = getVersionMapCacheKey(project, workspace);
@@ -279,163 +227,6 @@ function findDepPackageJson(packageName, projectRoot) {
     }
     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];
@@ -445,35 +236,6 @@ function getPkgFolder(packageName) {
     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',
@@ -605,25 +367,20 @@ function readConfiguredSecondaries(parent, libPath, exclude, shareObject) {
     return result;
 }
 function getDefaultEntry(exports, key) {
-    var _a;
-    let entry = '';
+    let entry;
     if (typeof exports[key] === 'string') {
         entry = exports[key];
     } else {
-        entry = (_a = exports[key]) === null || _a === void 0 ? void 0 : _a['default'];
+        var _exports_key;
+        entry = (_exports_key = exports[key]) == null ? void 0 : _exports_key['default'];
         if (typeof entry === 'object') {
             entry = entry['default'];
         }
     }
     return entry;
 }
-function shareAll(config = {}, skip = DEFAULT_SKIP_LIST, projectPath = '') {
-    // let workspacePath: string | undefined = undefined;
+function shareAll(config, skip = DEFAULT_SKIP_LIST, projectPath = '') {
     projectPath = inferProjectPath(projectPath);
-    // workspacePath = getConfigContext().workspaceRoot ?? '';
-    // if (!workspacePath) {
-    //   workspacePath = projectPath;
-    // }
     const versionMaps = getVersionMaps(projectPath, projectPath);
     const share = {};
     for (const versions of versionMaps){
@@ -644,7 +401,7 @@ function shareAll(config = {}, skip = DEFAULT_SKIP_LIST, projectPath = '') {
     return module.exports.share(share, projectPath);
 }
 function inferProjectPath(projectPath) {
-    if (!projectPath && getConfigContext().packageJson) {
+    if (!projectPath) {
         projectPath = path__default["default"].dirname(getConfigContext().packageJson || '');
     }
     if (!projectPath && getConfigContext().workspaceRoot) {
@@ -701,38 +458,6 @@ function addSecondaries(secondaries, result) {
     }
 }
 
-function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath }) {
-    var _tsConfig_compilerOptions;
-    const result = [];
-    if (!path__namespace.isAbsolute(rootTsConfigPath)) {
-        throw new Error('SharedMappings.register: tsConfigPath needs to be an absolute path!');
-    }
-    if (!rootPath) {
-        rootPath = path__namespace.normalize(path__namespace.dirname(rootTsConfigPath));
-    }
-    const shareAll = !sharedMappings;
-    if (!sharedMappings) {
-        sharedMappings = [];
-    }
-    const tsConfig = JSON5__namespace.parse(fs__namespace.readFileSync(rootTsConfigPath, {
-        encoding: 'utf-8'
-    }));
-    const mappings = tsConfig == null ? void 0 : (_tsConfig_compilerOptions = tsConfig.compilerOptions) == null ? void 0 : _tsConfig_compilerOptions.paths;
-    if (!mappings) {
-        return result;
-    }
-    for(const key in mappings){
-        const libPath = path__namespace.normalize(path__namespace.join(rootPath, mappings[key][0]));
-        if (sharedMappings.includes(key) || shareAll) {
-            result.push({
-                key,
-                path: libPath
-            });
-        }
-    }
-    return result;
-}
-
 function _extends() {
     _extends = Object.assign || function(target) {
         for(var i = 1; i < arguments.length; i++){
@@ -756,8 +481,7 @@ function withFederation(config) {
         filename: (_config_filename = config.filename) != null ? _config_filename : 'remoteEntry',
         exposes: (_config_exposes = config.exposes) != null ? _config_exposes : {},
         remotes: (_config_remotes = config.remotes) != null ? _config_remotes : {},
-        shared: normalizeShared(config, skip),
-        sharedMappings: normalizeSharedMappings(config, skip)
+        shared: normalizeShared(config, skip)
     };
 }
 function normalizeShared(config, skip) {
@@ -788,339 +512,23 @@ function normalizeShared(config, skip) {
         }), {});
     return result;
 }
-function normalizeSharedMappings(config, skip) {
-    const rootTsConfigPath = findRootTsConfigJson();
-    const paths = getMappedPaths({
-        rootTsConfigPath,
-        sharedMappings: config.sharedMappings
-    });
-    const result = paths.filter((p)=>!isInSkipList(p.key, skip) && !p.key.includes('*'));
-    if (paths.find((p)=>p.key.includes('*'))) {
-        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);
-    const hashSum = crypto__namespace.createHash('md5');
-    hashSum.update(fileBuffer);
-    return hashSum.digest('hex');
-}
 
 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;