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

package/dist/federation-builder.esm.js

@@ -1,697 +0,0 @@
-import npmlog from 'npmlog';
-import * as path from 'path';
-import path__default from 'path';
-import * as fs from 'fs';
-
-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$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.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 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.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$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.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 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;
-}
-
-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.join(fedOptions.workspaceRoot, fedOptions.federationConfig);
-    if (!fs.existsSync(fullConfigPath)) {
-        throw new Error('Expected ' + fullConfigPath);
-    }
-    const config = await import(`${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;
-    }
-};
-
-export { getConfigContext as a, findDepPackageJson as b, getBuildAdapter as c, writeFederationInfo as d, getExternals as e, federationBuilder as f, getVersionMaps as g, loadFederationConfig as h, defaultBuildParams as i, buildForFederation as j, bundleExposedAndMappings as k, logger as l, describeExposed as m, describeSharedMappings as n, setLogLevel as o, createBuildResultMap as p, lookupInResultMap as q, setBuildAdapter as s, writeImportMap as w };