@softarc/native-federation 4.1.2 → 4.2.0

package/src/lib/core/build-for-federation.js

@@ -1,173 +0,0 @@
-import { bundleExposedAndMappings, describeExposed, describeSharedMappings, } from './bundle-exposed-and-mappings.js';
-import { bundleShared } from './bundle-shared.js';
-import { writeFederationInfo } from './write-federation-info.js';
-import { writeImportMap } from './write-import-map.js';
-import { logger } from '../utils/logger.js';
-import { normalizePackageName } from '../utils/normalize.js';
-import { AbortedError } from '../utils/errors.js';
-import { addExternalsToCache } from './federation-cache.js';
-import path from 'path';
-export async function buildForFederation(config, fedOptions, externals, signal) {
-    // 1. Setup
-    fedOptions.federationCache.cachePath = path.join(fedOptions.federationCache.cachePath, fedOptions.projectName);
-    logger.info('Building federation artifacts');
-    logger.notice("Skip packages you don't want to share in your federation config");
-    // 2. Externals
-    if (fedOptions.federationCache.externals.length > 0) {
-        logger.info('Checksum matched, re-using cached externals.');
-    }
-    if (fedOptions.federationCache.externals.length === 0) {
-        const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(config.shared);
-        if (Object.keys(sharedBrowser).length > 0) {
-            logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
-            const start = process.hrtime();
-            const sharedPackageInfoBrowser = await bundleShared(sharedBrowser, config, fedOptions, externals, { platform: 'browser', bundleName: 'browser-shared', chunks: config.chunks });
-            logger.measure(start, 'Step 2.1) Bundling all shared browser externals');
-            addExternalsToCache(fedOptions.federationCache, sharedPackageInfoBrowser);
-            if (signal?.aborted)
-                throw new AbortedError('[buildForFederation] After shared-browser bundle');
-        }
-        if (Object.keys(sharedServer).length > 0) {
-            logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
-            const start = process.hrtime();
-            const sharedPackageInfoServer = await bundleShared(sharedServer, config, fedOptions, externals, { platform: 'node', bundleName: 'node-shared', chunks: config.chunks });
-            logger.measure(start, 'Step 2.1) Bundling all shared node externals');
-            addExternalsToCache(fedOptions.federationCache, sharedPackageInfoServer);
-            if (signal?.aborted)
-                throw new AbortedError('[buildForFederation] After shared-node bundle');
-        }
-        if (Object.keys(separateBrowser).length > 0) {
-            logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
-            const start = process.hrtime();
-            const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, { platform: 'browser' });
-            logger.measure(start, 'Step 2.2) Bundling all separate browser external packages');
-            addExternalsToCache(fedOptions.federationCache, separatePackageInfoBrowser);
-            if (signal?.aborted)
-                throw new AbortedError('[buildForFederation] After separate-browser bundle');
-        }
-        if (Object.keys(separateServer).length > 0) {
-            logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
-            const start = process.hrtime();
-            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, { platform: 'node' });
-            logger.measure(start, 'Step 2.2) Bundling all separate node external packages');
-            addExternalsToCache(fedOptions.federationCache, separatePackageInfoServer);
-        }
-        if (signal?.aborted)
-            throw new AbortedError('[buildForFederation] After separate-node bundle');
-    }
-    // 2. Shared mappings and exposed modules
-    const start = process.hrtime();
-    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, undefined, signal);
-    logger.measure(start, 'Step 3) Bundling all internal libraries and exposed modules.');
-    if (signal?.aborted)
-        throw new AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    const exposedInfo = !artifactInfo ? describeExposed(config, fedOptions) : artifactInfo.exposes;
-    const sharedMappingInfo = !artifactInfo
-        ? describeSharedMappings(config, fedOptions)
-        : artifactInfo.mappings;
-    const sharedExternals = [...fedOptions.federationCache.externals, ...sharedMappingInfo];
-    if (config?.shareScope) {
-        Object.values(sharedExternals).forEach(external => {
-            if (!external.shareScope)
-                external.shareScope = config.shareScope;
-        });
-    }
-    const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
-        ? fedOptions.buildNotifications?.endpoint
-        : undefined;
-    const federationInfo = {
-        name: config.name,
-        shared: sharedExternals,
-        exposes: exposedInfo,
-        buildNotificationsEndpoint,
-    };
-    if (fedOptions.federationCache.chunks) {
-        federationInfo.chunks = fedOptions.federationCache.chunks;
-    }
-    if (artifactInfo?.chunks) {
-        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
-    }
-    if (config.features.integrityHashes) {
-        federationInfo.integrity = {
-            ...(fedOptions.federationCache.integrity ?? {}),
-            ...(artifactInfo?.integrity ?? {}),
-        };
-    }
-    writeFederationInfo(federationInfo, fedOptions);
-    writeImportMap(fedOptions.federationCache, fedOptions, federationInfo.integrity);
-    return federationInfo;
-}
-function inferPackageFromSecondary(secondary) {
-    const parts = secondary.split('/');
-    if (secondary.startsWith('@') && parts.length >= 2) {
-        return parts[0] + '/' + parts[1];
-    }
-    return parts[0];
-}
-async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, buildOptions) {
-    const groupedByPackage = {};
-    for (const [key, shared] of Object.entries(separateBrowser)) {
-        const packageName = shared.build === 'separate' ? key : inferPackageFromSecondary(key);
-        if (!groupedByPackage[packageName]) {
-            groupedByPackage[packageName] = {
-                chunks: shared.chunks,
-                entries: {},
-            };
-        }
-        groupedByPackage[packageName].entries[key] = shared;
-    }
-    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, packageConfig]) => {
-        return bundleShared(packageConfig.entries, config, fedOptions, externals.filter(e => !e.startsWith(packageName)), {
-            platform: buildOptions.platform,
-            chunks: packageConfig.chunks,
-            bundleName: `${buildOptions.platform}-${normalizePackageName(packageName)}`,
-        });
-    });
-    const buildResults = await Promise.all(bundlePromises);
-    return buildResults.reduce((acc, r) => {
-        let chunks = acc.chunks;
-        if (r.chunks) {
-            chunks = { ...(acc.chunks ?? {}), ...r.chunks };
-        }
-        let integrity = acc.integrity;
-        if (r.integrity) {
-            integrity = { ...(acc.integrity ?? {}), ...r.integrity };
-        }
-        return {
-            externals: [...acc.externals, ...r.externals],
-            chunks,
-            integrity,
-        };
-    }, { externals: [] });
-}
-function splitShared(shared) {
-    const sharedServer = {};
-    const sharedBrowser = {};
-    const separateBrowser = {};
-    const separateServer = {};
-    for (const key in shared) {
-        const obj = shared[key];
-        if (obj?.platform === 'node') {
-            if (obj.build === 'default') {
-                sharedServer[key] = obj;
-            }
-            else {
-                separateServer[key] = obj;
-            }
-        }
-        else if (obj?.platform === 'browser') {
-            if (obj.build === 'default') {
-                sharedBrowser[key] = obj;
-            }
-            else {
-                separateBrowser[key] = obj;
-            }
-        }
-    }
-    return {
-        sharedBrowser,
-        sharedServer,
-        separateBrowser,
-        separateServer,
-    };
-}

package/src/lib/core/bundle-exposed-and-mappings.d.ts

@@ -1,7 +0,0 @@
-import type { ArtifactInfo, ExposesInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
-import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles?: string[], signal?: AbortSignal): Promise<ArtifactInfo>;
-export declare function describeExposed(config: NormalizedFederationConfig, options: NormalizedFederationOptions): Array<ExposesInfo>;
-export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions): Array<SharedInfo>;
-export declare function getMappingVersion(fileName: string, workspaceRoot: string): string;

package/src/lib/core/bundle-exposed-and-mappings.js

@@ -1,174 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { integrityForFile } from '../utils/hash-file.js';
-import { createBuildResultMap, popFromResultMap } from '../utils/build-result-map.js';
-import { logger } from '../utils/logger.js';
-import { normalize } from '../utils/normalize.js';
-import { AbortedError } from '../utils/errors.js';
-import { rewriteChunkImports } from '../utils/rewrite-chunk-imports.js';
-import { getBuildAdapter } from './build-adapter.js';
-export async function bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal) {
-    if (signal?.aborted) {
-        throw new AbortedError('[bundle-exposed-and-mappings] Aborted before bundling');
-    }
-    const shared = Object.entries(config.sharedMappings).map(([entryPoint, mappedImport]) => {
-        return {
-            fileName: entryPoint,
-            outName: mappedImport.replace(/[^A-Za-z0-9]/g, '_') + '.js',
-            key: mappedImport,
-        };
-    });
-    const exposes = Object.entries(config.exposes).map(([key, entry]) => {
-        const outFilePath = key + '.js';
-        return { fileName: entry, outName: outFilePath, key };
-    });
-    const entryPoints = [...shared, ...exposes];
-    const hash = !fedOptions.dev;
-    let result;
-    try {
-        if (!modifiedFiles) {
-            await getBuildAdapter().setup('mapping-or-exposed', {
-                entryPoints,
-                outdir: fedOptions.outputPath,
-                tsConfigPath: fedOptions.tsConfig,
-                external: externals,
-                dev: !!fedOptions.dev,
-                watch: fedOptions.watch,
-                mappedPaths: config.sharedMappings,
-                chunks: config.chunks,
-                hash,
-                optimizedMappings: config.features.ignoreUnusedDeps,
-                isMappingOrExposed: true,
-                cache: fedOptions.federationCache,
-            });
-        }
-        result = await getBuildAdapter().build('mapping-or-exposed', {
-            signal,
-            modifiedFiles,
-        });
-        if (signal?.aborted) {
-            throw new AbortedError('[bundle-exposed-and-mappings] Aborted after bundle');
-        }
-    }
-    catch (error) {
-        if (!(error instanceof AbortedError)) {
-            logger.error('Error building federation artifacts');
-        }
-        throw error;
-    }
-    const resultMap = createBuildResultMap(result, hash, [
-        ...shared.map(s => s.outName),
-        ...exposes.map(e => e.outName),
-    ]);
-    const sharedResult = [];
-    const entryFiles = [];
-    // Pick shared-mappings
-    for (const item of shared) {
-        const distEntryFile = popFromResultMap(resultMap, item.outName);
-        sharedResult.push(toSharedMappingInfo(item.fileName, item.key, path.basename(distEntryFile), config, fedOptions));
-        entryFiles.push(distEntryFile);
-    }
-    const exposedResult = [];
-    // Pick exposed-modules
-    for (const item of exposes) {
-        const distEntryFile = popFromResultMap(resultMap, item.outName);
-        exposedResult.push({
-            key: item.key,
-            outFileName: path.basename(distEntryFile),
-            dev: !fedOptions.dev
-                ? undefined
-                : {
-                    entryPoint: normalize(path.join(fedOptions.workspaceRoot, item.fileName)),
-                },
-        });
-        entryFiles.push(distEntryFile);
-    }
-    // Remove .map files
-    Object.keys(resultMap)
-        .filter(f => f.endsWith('.map'))
-        .forEach(f => popFromResultMap(resultMap, f));
-    // Process remaining chunks and lazy loaded internal modules
-    let exportedChunks = undefined;
-    const chunkPaths = [];
-    if (config.chunks && config.features.denseChunking) {
-        for (const entryFile of entryFiles)
-            rewriteChunkImports(entryFile);
-        chunkPaths.push(...Object.values(resultMap));
-        exportedChunks = {
-            ['mapping-or-exposed']: chunkPaths.map(chunk => path.basename(chunk)),
-        };
-    }
-    // Must run after rewriteChunkImports so SRI matches the final on-disk bytes.
-    let integrity;
-    if (config.features.integrityHashes) {
-        integrity = {};
-        for (const filePath of [...entryFiles, ...chunkPaths]) {
-            if (!fs.existsSync(filePath))
-                continue;
-            integrity[path.basename(filePath)] = integrityForFile(filePath);
-        }
-    }
-    return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks, integrity };
-}
-export function describeExposed(config, options) {
-    const result = [];
-    for (const key in config.exposes) {
-        const localPath = normalize(path.normalize(path.join(options.workspaceRoot, config.exposes[key])));
-        result.push({
-            key,
-            outFileName: '',
-            dev: !options.dev
-                ? undefined
-                : {
-                    entryPoint: localPath,
-                },
-        });
-    }
-    return result;
-}
-export function describeSharedMappings(config, fedOptions) {
-    const result = [];
-    for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
-        result.push(toSharedMappingInfo(mappedPath, mappedImport, '', config, fedOptions));
-    }
-    return result;
-}
-function toSharedMappingInfo(mappedPath, mappedImport, outFileName, config, fedOptions) {
-    const mappingVersion = config.features.mappingVersion
-        ? getMappingVersion(mappedPath, fedOptions.workspaceRoot)
-        : '';
-    return {
-        packageName: mappedImport,
-        outFileName,
-        requiredVersion: mappingVersion.length > 0 ? '~' + mappingVersion : '',
-        singleton: true,
-        strictVersion: config.features.mappingVersion,
-        version: mappingVersion,
-        dev: !fedOptions.dev
-            ? undefined
-            : {
-                entryPoint: normalize(path.normalize(mappedPath)),
-            },
-    };
-}
-export function getMappingVersion(fileName, workspaceRoot) {
-    const resolvedRoot = path.resolve(workspaceRoot);
-    let dir = path.dirname(path.resolve(fileName));
-    while (true) {
-        const candidate = path.join(dir, 'package.json');
-        try {
-            const json = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
-            if (typeof json.version === 'string' && json.version)
-                return json.version;
-        }
-        catch (err) {
-            if (err.code !== 'ENOENT') {
-                logger.warn(`[getMappingVersion] Failed to parse ${candidate}: ${err.message}`);
-            }
-        }
-        const parent = path.dirname(dir);
-        if (dir === resolvedRoot || parent === dir)
-            return '';
-        dir = parent;
-    }
-}

package/src/lib/core/bundle-shared.d.ts

@@ -1,13 +0,0 @@
-import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
-import type { IntegrityMap, SharedInfo } from '../domain/core/federation-info.contract.js';
-import { type NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
-import type { NormalizedExternalConfig } from '../domain/config/external-config.contract.js';
-export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
-    platform: 'browser' | 'node';
-    bundleName: string;
-    chunks: boolean;
-}): Promise<{
-    externals: SharedInfo[];
-    chunks?: Record<string, string[]>;
-    integrity?: IntegrityMap;
-}>;

package/src/lib/core/bundle-shared.js

@@ -1,222 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import { getPackageInfo } from '../utils/package-info.js';
-import { logger } from '../utils/logger.js';
-import crypto from 'crypto';
-import { DEFAULT_EXTERNAL_LIST } from './default-external-list.js';
-import { isSourceFile, rewriteChunkImports } from '../utils/rewrite-chunk-imports.js';
-import { toChunkImport } from '../domain/core/chunk.js';
-import { cacheEntry, getChecksum, getFilename } from '../utils/cache-persistence.js';
-import { fileURLToPath } from 'url';
-import { getBuildAdapter } from './build-adapter.js';
-import { integrityForFile } from '../utils/hash-file.js';
-export async function bundleShared(sharedBundles, config, fedOptions, externals, buildOptions) {
-    const checksum = getChecksum(sharedBundles, fedOptions.dev ? '1' : '0');
-    const folder = fedOptions.packageJson
-        ? path.dirname(fedOptions.packageJson)
-        : fedOptions.workspaceRoot;
-    const bundleCache = cacheEntry(fedOptions.federationCache.cachePath, getFilename(buildOptions.bundleName, fedOptions.dev));
-    if (fedOptions?.cacheExternalArtifacts) {
-        const cacheMetadata = bundleCache.getMetadata(checksum);
-        if (cacheMetadata) {
-            logger.debug(`Checksum of ${buildOptions.bundleName} matched, Skipped artifact bundling`);
-            bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-            let integrity = cacheMetadata.integrity;
-            if (config.features.integrityHashes && !integrity) {
-                integrity = computeIntegrityForFiles(cacheMetadata.files, fedOptions.federationCache.cachePath);
-            }
-            return {
-                externals: cacheMetadata.externals,
-                chunks: cacheMetadata.chunks,
-                integrity,
-            };
-        }
-    }
-    bundleCache.clear();
-    const inferredPackageInfos = Object.keys(sharedBundles)
-        .filter(packageName => !sharedBundles[packageName]?.packageInfo)
-        .map(packageName => getPackageInfo(packageName, folder))
-        .filter(pi => !!pi);
-    const configuredPackageInfos = Object.keys(sharedBundles)
-        .filter(packageName => !!sharedBundles[packageName]?.packageInfo)
-        .map(packageName => ({
-        packageName,
-        ...sharedBundles[packageName]?.packageInfo,
-    }));
-    const packageInfos = [...inferredPackageInfos, ...configuredPackageInfos];
-    const __filename = fileURLToPath(import.meta.url);
-    const configState = 'BUNDLER_CHUNKS' + // TODO: Replace this with lib version
-        fs.readFileSync(path.join(path.dirname(__filename), '../../../package.json')) +
-        JSON.stringify(config);
-    const allEntryPoints = packageInfos.map(pi => {
-        const encName = pi.packageName.replace(/[^A-Za-z0-9]/g, '_');
-        const outName = createOutName(pi, configState, fedOptions, encName);
-        return { fileName: pi.entryPoint, outName };
-    });
-    const fullOutputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
-    const expectedResults = allEntryPoints.map(ep => path.join(fullOutputPath, ep.outName));
-    const entryPoints = allEntryPoints.filter(ep => !fs.existsSync(path.join(fedOptions.federationCache.cachePath, ep.outName)));
-    // If we build for the browser and don't remote unused deps from the shared config,
-    // we need to exclude typical node libs to avoid compilation issues
-    const useDefaultExternalList = buildOptions.platform === 'browser' && !config.features.ignoreUnusedDeps;
-    const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
-    let bundleResult = null;
-    try {
-        await getBuildAdapter().setup(buildOptions.bundleName, {
-            entryPoints,
-            tsConfigPath: fedOptions.tsConfig,
-            external: [...additionalExternals, ...externals],
-            outdir: fedOptions.federationCache.cachePath,
-            mappedPaths: config.sharedMappings,
-            dev: fedOptions.dev,
-            isMappingOrExposed: false,
-            hash: false,
-            chunks: buildOptions.chunks,
-            platform: buildOptions.platform,
-            optimizedMappings: config.features.ignoreUnusedDeps,
-            cache: fedOptions.federationCache,
-        });
-        bundleResult = await getBuildAdapter().build(buildOptions.bundleName);
-        await getBuildAdapter().dispose(buildOptions.bundleName);
-        const cachedFiles = bundleResult.map(br => path.basename(br.fileName));
-        rewriteImports(cachedFiles, fedOptions.federationCache.cachePath);
-    }
-    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);
-        throw e;
-    }
-    const outFileNames = [...expectedResults];
-    const result = buildResult(packageInfos, sharedBundles, outFileNames);
-    const chunks = bundleResult.filter(br => !br.fileName.endsWith('.map') &&
-        !result.find(r => r.outFileName === path.basename(br.fileName)));
-    /**
-     * Chunking
-     */
-    let exportedChunks = undefined;
-    if (buildOptions.chunks && config.features.denseChunking) {
-        result.forEach(external => {
-            external.bundle = buildOptions.bundleName;
-        });
-        if (chunks.length > 0) {
-            exportedChunks = { [buildOptions.bundleName]: getChunkFileNames(chunks) };
-        }
-    }
-    else {
-        addChunksToResult(chunks, result);
-    }
-    const persistedFiles = bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName);
-    // Must run after rewriteImports so SRI matches the bytes copied to dist.
-    const integrity = config.features.integrityHashes
-        ? computeIntegrityForFiles(persistedFiles, fedOptions.federationCache.cachePath)
-        : undefined;
-    bundleCache.persist({
-        checksum,
-        externals: result,
-        files: persistedFiles,
-        chunks: exportedChunks,
-        integrity,
-    });
-    bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-    return { externals: result, chunks: exportedChunks, integrity };
-}
-function computeIntegrityForFiles(files, baseDir) {
-    const integrity = {};
-    for (const file of files) {
-        if (file.endsWith('.map'))
-            continue;
-        const fullPath = path.join(baseDir, file);
-        if (!fs.existsSync(fullPath))
-            continue;
-        integrity[path.basename(file)] = integrityForFile(fullPath);
-    }
-    return integrity;
-}
-function rewriteImports(cachedFiles, cachePath) {
-    const newSourceFiles = cachedFiles.filter(cf => isSourceFile(cf));
-    for (const sourceFile of newSourceFiles) {
-        const sourceFilePath = path.join(cachePath, sourceFile);
-        rewriteChunkImports(sourceFilePath);
-    }
-}
-function createOutName(pi, configState, fedOptions, encName) {
-    const hashBase = pi.version + '_' + pi.entryPoint + '_' + configState;
-    const hash = calcHash(hashBase);
-    const outName = fedOptions.dev ? `${encName}.${hash}-dev.js` : `${encName}.${hash}.js`;
-    return outName;
-}
-function buildResult(packageInfos, sharedBundles, outFileNames) {
-    return packageInfos.map(pi => {
-        const shared = sharedBundles[pi.packageName];
-        return {
-            packageName: pi.packageName,
-            outFileName: path.basename(outFileNames.shift() || ''),
-            requiredVersion: shared?.requiredVersion,
-            singleton: shared?.singleton,
-            strictVersion: shared?.strictVersion,
-            version: pi.version,
-            ...(shared?.shareScope && { shareScope: shared.shareScope }),
-            // TODO: Decide whether/when we need debug infos
-            // dev: !fedOptions.dev
-            //   ? undefined
-            //   : {
-            //       entryPoint: normalize(pi.entryPoint),
-            //     },
-        };
-    });
-}
-function getChunkFileNames(chunks) {
-    return chunks.map(chunk => path.basename(chunk.fileName));
-}
-function addChunksToResult(chunks, result) {
-    for (const item of chunks) {
-        const fileName = path.basename(item.fileName);
-        result.push({
-            singleton: false,
-            strictVersion: false,
-            // Here, the version does not matter because
-            // a) a chunk split off by the bundler does
-            // not have a version and b) it gets a hash
-            // code as part of the file name to be unique
-            // when requested via a _versioned_ package.
-            //
-            // For the same reason, we don't need to
-            // take care of singleton and strictVersion.
-            version: '0.0.0',
-            requiredVersion: '0.0.0',
-            packageName: toChunkImport(fileName),
-            outFileName: fileName,
-            // dev: dev
-            //   ? undefined
-            //   : {
-            //       entryPoint: normalize(fileName),
-            //     },
-        });
-    }
-}
-function calcHash(hashBase) {
-    const hash = crypto
-        .createHash('sha256')
-        .update(hashBase)
-        .digest('base64')
-        .replace(/\//g, '_')
-        .replace(/\+/g, '-')
-        .replace(/=/g, '')
-        .substring(0, 10);
-    return hash;
-}

package/src/lib/core/default-external-list.js

@@ -1,29 +0,0 @@
-const NODE_PACKAGES = [
-    'assert',
-    'buffer',
-    'child_process',
-    'cluster',
-    'crypto',
-    'dgram',
-    'dns',
-    'events',
-    'fs',
-    'http',
-    'https',
-    'module',
-    'net',
-    'os',
-    'path',
-    'querystring',
-    'readline',
-    'stream',
-    'timers',
-    'tls',
-    'tty',
-    'url',
-    'util',
-    'v8',
-    'vm',
-    'zlib',
-];
-export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap(p => [p, 'node:' + p]);

package/src/lib/core/federation-builder.js

@@ -1,45 +0,0 @@
-import { getConfigContext, usePackageJson, useWorkspace } from '../config/configuration-context.js';
-import { getBuildAdapter, setBuildAdapter } from './build-adapter.js';
-import { buildForFederation } from './build-for-federation.js';
-import { getExternals } from './get-externals.js';
-import { normalizeFederationOptions } from './normalize-options.js';
-import { rebuildForFederation } from './rebuild-for-federation.js';
-let externals = [];
-let config;
-let options;
-let fedInfo;
-async function init(params) {
-    setBuildAdapter(params.adapter);
-    useWorkspace(params.options.workspaceRoot);
-    usePackageJson(params.options.packageJson);
-    params.options.workspaceRoot = getConfigContext().workspaceRoot ?? params.options.workspaceRoot;
-    const normalized = await normalizeFederationOptions(params.options);
-    options = normalized.options;
-    config = normalized.config;
-    externals = getExternals(config);
-}
-async function build(opts = {}) {
-    if (!fedInfo) {
-        fedInfo = await buildForFederation(config, options, externals, opts.signal);
-    }
-    else {
-        fedInfo = await rebuildForFederation(config, options, externals, opts.modifiedFiles ?? [], opts.signal);
-    }
-}
-async function close() {
-    return getBuildAdapter().dispose();
-}
-export const federationBuilder = {
-    init,
-    build,
-    close,
-    get federationInfo() {
-        return fedInfo;
-    },
-    get externals() {
-        return externals;
-    },
-    get config() {
-        return config;
-    },
-};