@softarc/native-federation 4.0.0-RC1 → 4.0.0-RC10

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

@@ -1,19 +1,21 @@
 import fs from 'fs';
 import path from 'path';
-import { createBuildResultMap, lookupInResultMap } from '../utils/build-result-map.js';
-import { bundle } from '../utils/build-utils.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';
-export async function bundleExposedAndMappings(config, fedOptions, externals, signal) {
+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 = 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 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';
@@ -21,21 +23,27 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, si
     });
     const entryPoints = [...shared, ...exposes];
     const hash = !fedOptions.dev;
-    logger.info('Building federation artefacts');
     let result;
     try {
-        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,
-            optimizedMappings: config.features.ignoreUnusedDeps,
+        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');
@@ -43,16 +51,19 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, si
     }
     catch (error) {
         if (!(error instanceof AbortedError)) {
-            logger.error('Error building federation artefacts');
+            logger.error('Error building federation artifacts');
         }
         throw error;
     }
     const resultMap = createBuildResultMap(result, hash);
     const sharedResult = [];
+    const entryFiles = [];
+    // Pick shared-mappings
     for (const item of shared) {
+        const distEntryFile = popFromResultMap(resultMap, item.outName);
         sharedResult.push({
             packageName: item.key,
-            outFileName: lookupInResultMap(resultMap, item.outName),
+            outFileName: path.basename(distEntryFile),
             requiredVersion: '',
             singleton: true,
             strictVersion: false,
@@ -63,20 +74,37 @@ export async function bundleExposedAndMappings(config, fedOptions, externals, si
                     entryPoint: normalize(path.normalize(item.fileName)),
                 },
         });
+        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: lookupInResultMap(resultMap, item.outName),
+            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;
+    if (config.chunks && config.features.denseChunking) {
+        for (const entryFile of entryFiles)
+            rewriteChunkImports(entryFile);
+        exportedChunks = {
+            ['mapping-or-exposed']: Object.values(resultMap).map(chunk => path.basename(chunk)),
+        };
     }
-    return { mappings: sharedResult, exposes: exposedResult };
+    return { mappings: sharedResult, exposes: exposedResult, chunks: exportedChunks };
 }
 export function describeExposed(config, options) {
     const result = [];
@@ -96,18 +124,18 @@ export function describeExposed(config, options) {
 }
 export function describeSharedMappings(config, fedOptions) {
     const result = [];
-    for (const m of config.sharedMappings) {
+    for (const [mappedPath, mappedImport] of Object.entries(config.sharedMappings)) {
         result.push({
-            packageName: m.key,
+            packageName: mappedImport,
             outFileName: '',
             requiredVersion: '',
             singleton: true,
             strictVersion: false,
-            version: config.features.mappingVersion ? getMappingVersion(m.path) : '',
+            version: config.features.mappingVersion ? getMappingVersion(mappedPath) : '',
             dev: !fedOptions.dev
                 ? undefined
                 : {
-                    entryPoint: normalize(path.normalize(m.path)),
+                    entryPoint: normalize(path.normalize(mappedPath)),
                 },
         });
     }

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

@@ -1,9 +1,12 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 import type { SharedInfo } from '../domain/core/federation-info.contract.js';
-import { type FederationOptions } from '../domain/core/federation-options.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: FederationOptions, externals: string[], platform: "browser" | "node" | undefined, cacheOptions: {
-    pathToCache: string;
+export declare function bundleShared(sharedBundles: Record<string, NormalizedExternalConfig>, config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], buildOptions: {
+    platform: 'browser' | 'node';
     bundleName: string;
-}): Promise<Array<SharedInfo>>;
-//# sourceMappingURL=bundle-shared.d.ts.map
+    chunks: boolean;
+}): Promise<{
+    externals: SharedInfo[];
+    chunks?: Record<string, string[]>;
+}>;

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

@@ -1,25 +1,26 @@
 import * as path from 'path';
 import * as fs from 'fs';
-import { bundle } from '../utils/build-utils.js';
 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 { deriveInternalName, isSourceFile, rewriteChunkImports, } from '../utils/rewrite-chunk-imports.js';
-import { cacheEntry, getChecksum, getFilename } from './../utils/bundle-caching.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';
-export async function bundleShared(sharedBundles, config, fedOptions, externals, platform = 'browser', cacheOptions) {
+import { getBuildAdapter } from './build-adapter.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(cacheOptions.pathToCache, getFilename(cacheOptions.bundleName, fedOptions.dev));
+    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 ${cacheOptions.bundleName} matched, Skipped artifact bundling`);
+            logger.debug(`Checksum of ${buildOptions.bundleName} matched, Skipped artifact bundling`);
             bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-            return cacheMetadata.externals;
+            return { externals: cacheMetadata.externals, chunks: cacheMetadata.chunks };
         }
     }
     bundleCache.clear();
@@ -45,27 +46,31 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
     });
     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(cacheOptions.pathToCache, 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 = platform === 'browser' && !config.features.ignoreUnusedDeps;
+    const useDefaultExternalList = buildOptions.platform === 'browser' && !config.features.ignoreUnusedDeps;
     const additionalExternals = useDefaultExternalList ? DEFAULT_EXTERNAL_LIST : [];
     let bundleResult = null;
     try {
-        bundleResult = await bundle({
+        await getBuildAdapter().setup(buildOptions.bundleName, {
             entryPoints,
             tsConfigPath: fedOptions.tsConfig,
             external: [...additionalExternals, ...externals],
-            outdir: cacheOptions.pathToCache,
+            outdir: fedOptions.federationCache.cachePath,
             mappedPaths: config.sharedMappings,
             dev: fedOptions.dev,
-            kind: 'shared-package',
+            isMappingOrExposed: false,
             hash: false,
-            platform,
+            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, cacheOptions.pathToCache);
+        rewriteImports(cachedFiles, fedOptions.federationCache.cachePath);
     }
     catch (e) {
         logger.error('Error bundling shared npm package ');
@@ -89,17 +94,31 @@ export async function bundleShared(sharedBundles, config, fedOptions, externals,
     }
     const outFileNames = [...expectedResults];
     const result = buildResult(packageInfos, sharedBundles, outFileNames);
-    // TODO: Decide whether/when to add .map files
     const chunks = bundleResult.filter(br => !br.fileName.endsWith('.map') &&
         !result.find(r => r.outFileName === path.basename(br.fileName)));
-    addChunksToResult(chunks, result);
+    /**
+     * 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);
+    }
     bundleCache.persist({
         checksum,
         externals: result,
         files: bundleResult.map(r => r.fileName.split(path.sep).pop() ?? r.fileName),
+        chunks: exportedChunks,
     });
     bundleCache.copyFiles(path.join(fedOptions.workspaceRoot, fedOptions.outputPath));
-    return result;
+    return { externals: result, chunks: exportedChunks };
 }
 function rewriteImports(cachedFiles, cachePath) {
     const newSourceFiles = cachedFiles.filter(cf => isSourceFile(cf));
@@ -124,6 +143,7 @@ function buildResult(packageInfos, sharedBundles, outFileNames) {
             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
@@ -133,6 +153,9 @@ function buildResult(packageInfos, sharedBundles, outFileNames) {
         };
     });
 }
+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);
@@ -149,7 +172,7 @@ function addChunksToResult(chunks, result) {
             // take care of singleton and strictVersion.
             version: '0.0.0',
             requiredVersion: '0.0.0',
-            packageName: deriveInternalName(fileName),
+            packageName: toChunkImport(fileName),
             outFileName: fileName,
             // dev: dev
             //   ? undefined

package/src/lib/core/default-external-list.d.ts

@@ -1,2 +1 @@
 export declare const DEFAULT_EXTERNAL_LIST: string[];
-//# sourceMappingURL=default-external-list.d.ts.map

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

@@ -26,7 +26,4 @@ const NODE_PACKAGES = [
     'vm',
     'zlib',
 ];
-export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap((p) => [
-    p,
-    'node:' + p,
-]);
+export const DEFAULT_EXTERNAL_LIST = NODE_PACKAGES.flatMap(p => [p, 'node:' + p]);

package/src/lib/core/federation-builder.d.ts

@@ -7,13 +7,17 @@ export interface BuildHelperParams {
     adapter: NFBuildAdapter;
 }
 declare function init(params: BuildHelperParams): Promise<void>;
-declare function build(buildParams?: import("../../domain.js").BuildParams): Promise<void>;
+declare function build(opts?: {
+    modifiedFiles?: string[];
+    signal?: AbortSignal;
+}): Promise<void>;
+declare function close(): Promise<void>;
 export declare const federationBuilder: {
     init: typeof init;
     build: typeof build;
+    close: typeof close;
     readonly federationInfo: FederationInfo;
     readonly externals: string[];
     readonly config: NormalizedFederationConfig;
 };
 export {};
-//# sourceMappingURL=federation-builder.d.ts.map

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

@@ -1,27 +1,38 @@
 import { getConfigContext, usePackageJson, useWorkspace } from '../config/configuration-context.js';
-import { setBuildAdapter } from './build-adapter.js';
-import { buildForFederation, defaultBuildParams } from './build-for-federation.js';
+import { getBuildAdapter, setBuildAdapter } from './build-adapter.js';
+import { buildForFederation } from './build-for-federation.js';
 import { getExternals } from './get-externals.js';
-import { loadFederationConfig } from './load-federation-config.js';
+import { normalizeFederationOptions } from './normalize-options.js';
+import { rebuildForFederation } from './rebuild-for-federation.js';
 let externals = [];
 let config;
-let fedOptions;
+let options;
 let fedInfo;
 async function init(params) {
     setBuildAdapter(params.adapter);
-    fedOptions = params.options;
     useWorkspace(params.options.workspaceRoot);
     usePackageJson(params.options.packageJson);
-    config = await loadFederationConfig(fedOptions);
     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(buildParams = defaultBuildParams) {
-    fedInfo = await buildForFederation(config, fedOptions, externals, buildParams);
+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;
     },

package/src/lib/core/federation-cache.d.ts

@@ -0,0 +1,8 @@
+import type { FederationCache } from '../domain/core/federation-cache.contract.js';
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
+export declare function createFederationCache(cachePath: string): FederationCache<undefined>;
+export declare function createFederationCache<TBundlerCache>(cachePath: string, bundlerCache: TBundlerCache): FederationCache<TBundlerCache>;
+export declare function addExternalsToCache(cache: FederationCache, { externals, chunks }: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}): void;

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

@@ -0,0 +1,11 @@
+export function createFederationCache(cachePath, bundlerCache) {
+    return { externals: [], cachePath, bundlerCache };
+}
+export function addExternalsToCache(cache, { externals, chunks }) {
+    cache.externals.push(...externals);
+    if (chunks) {
+        if (!cache.chunks)
+            cache.chunks = {};
+        cache.chunks = { ...cache.chunks, ...chunks };
+    }
+}

package/src/lib/core/get-externals.d.ts

@@ -1,3 +1,2 @@
 import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
 export declare function getExternals(config: NormalizedFederationConfig): string[];
-//# sourceMappingURL=get-externals.d.ts.map

package/src/lib/core/get-externals.js

@@ -1,6 +1,6 @@
 export function getExternals(config) {
     const shared = Object.keys(config.shared);
-    const sharedMappings = config.sharedMappings.map(m => m.key);
+    const sharedMappings = Object.values(config.sharedMappings);
     const externals = [...shared, ...sharedMappings, ...config.externals];
     return externals;
 }

package/src/lib/core/normalize-options.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+import type { FederationOptions, NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import { type FederationCache } from '../../domain.js';
+export declare function normalizeFederationOptions(options: FederationOptions): Promise<{
+    config: NormalizedFederationConfig;
+    options: NormalizedFederationOptions<undefined>;
+}>;
+export declare function normalizeFederationOptions<TBundlerCache>(options: FederationOptions, cache: FederationCache<TBundlerCache>): Promise<{
+    config: NormalizedFederationConfig;
+    options: NormalizedFederationOptions<TBundlerCache>;
+}>;
+export declare function resolveProjectName(name?: string): string;

package/src/lib/core/normalize-options.js

@@ -0,0 +1,57 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+import { removeUnusedDeps } from '../config/remove-unused-deps.js';
+import { createFederationCache } from './federation-cache.js';
+import { getDefaultCachePath } from '../utils/cache-persistence.js';
+import { getUsedDependenciesFactory } from '../utils/get-used-dependencies.js';
+import { logger } from '../utils/logger.js';
+import { normalizePackageName } from '../utils/normalize.js';
+export async function normalizeFederationOptions(options, cache) {
+    /**
+     * Step 1: normalizing config
+     */
+    const fullConfigPath = path.join(options.workspaceRoot, options.federationConfig);
+    const getUsedDeps = getUsedDependenciesFactory(options.workspaceRoot, options.entryPoints);
+    if (!fs.existsSync(fullConfigPath)) {
+        throw new Error('Expected ' + fullConfigPath);
+    }
+    let config = (await import(pathToFileURL(fullConfigPath).href))
+        ?.default;
+    /**
+     * Step 2: normalizing options
+     */
+    const federationCache = cache ??
+        createFederationCache(getDefaultCachePath(options.workspaceRoot));
+    const normalizedOptions = {
+        ...options,
+        entryPoints: options.entryPoints ?? Object.values(config.exposes ?? {}),
+        projectName: resolveProjectName(options.projectName ?? config.name),
+        federationCache,
+    };
+    /**
+     * Step 3: Remove unused deps
+     */
+    if (config.features.ignoreUnusedDeps) {
+        config = removeUnusedDeps(getUsedDeps(config), config);
+        logger.info('Removed unused dependencies.');
+        logger.debug('This can be disabled per dependency/external using the "includeSecondaries: {keepAll: true}" property. Or in general by disabling the "ignoreUnusedDeps" feature. ');
+    }
+    else {
+        const withWildcard = Object.keys(config.sharedMappings).some(m => m.includes('*'));
+        if (withWildcard) {
+            logger.warn('Sharing mapped paths with wildcards (*) is only supported with ignoreUnusedDeps feature.');
+            config.sharedMappings = Object.entries(config.sharedMappings)
+                .filter(([_path]) => !_path.includes('*'))
+                .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
+        }
+    }
+    return { config, options: normalizedOptions };
+}
+export function resolveProjectName(name) {
+    if (!name || name.length < 1) {
+        logger.warn("Project name in 'federation.config.js' is empty, defaulting to 'shell' cache folder (could collide with other projects in the workspace).");
+        return 'shell';
+    }
+    return normalizePackageName(name);
+}

package/src/lib/core/rebuild-for-federation.d.ts

@@ -0,0 +1,4 @@
+import type { FederationInfo } from '../domain/core/federation-info.contract.js';
+import type { NormalizedFederationOptions } from '../domain/core/federation-options.contract.js';
+import type { NormalizedFederationConfig } from '../domain/config/federation-config.contract.js';
+export declare function rebuildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], modifiedFiles: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -0,0 +1,37 @@
+import { bundleExposedAndMappings, describeExposed, describeSharedMappings, } from './bundle-exposed-and-mappings.js';
+import { writeFederationInfo } from './write-federation-info.js';
+import { writeImportMap } from './write-import-map.js';
+import { logger } from '../utils/logger.js';
+import { AbortedError } from '../utils/errors.js';
+export async function rebuildForFederation(config, fedOptions, externals, modifiedFiles, signal) {
+    const federationCache = fedOptions.federationCache;
+    logger.info(`Re-bundling all internal libraries and exposed modules..'`);
+    const start = process.hrtime();
+    const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal);
+    logger.measure(start, 'To re-bundle 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 = [...federationCache.externals, ...sharedMappingInfo];
+    const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
+        ? fedOptions.buildNotifications?.endpoint
+        : undefined;
+    const federationInfo = {
+        name: config.name,
+        shared: sharedExternals,
+        exposes: exposedInfo,
+        buildNotificationsEndpoint,
+    };
+    if (federationCache.chunks) {
+        federationInfo.chunks = federationCache.chunks;
+    }
+    if (artifactInfo?.chunks) {
+        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
+    }
+    writeFederationInfo(federationInfo, fedOptions);
+    writeImportMap(federationCache, fedOptions);
+    return federationInfo;
+}

package/src/lib/core/write-federation-info.d.ts

@@ -1,4 +1,3 @@
 import type { FederationInfo } from '../domain/core/federation-info.contract.js';
 import type { FederationOptions } from '../domain/core/federation-options.contract.js';
 export declare function writeFederationInfo(federationInfo: FederationInfo, fedOptions: FederationOptions): void;
-//# sourceMappingURL=write-federation-info.d.ts.map

package/src/lib/core/write-import-map.d.ts

@@ -1,4 +1,6 @@
-import type { SharedInfo } from '../domain/core/federation-info.contract.js';
+import type { ChunkInfo, SharedInfo } from '../domain/core/federation-info.contract.js';
 import type { FederationOptions } from '../domain/core/federation-options.contract.js';
-export declare function writeImportMap(sharedInfo: SharedInfo[], fedOption: FederationOptions): void;
-//# sourceMappingURL=write-import-map.d.ts.map
+export declare function writeImportMap(sharedInfo: {
+    externals: SharedInfo[];
+    chunks?: ChunkInfo;
+}, fedOption: FederationOptions): void;

package/src/lib/core/write-import-map.js

@@ -1,12 +1,21 @@
 import * as path from 'path';
 import * as fs from 'fs';
+import { toChunkImport } from '../domain/core/chunk.js';
 export function writeImportMap(sharedInfo, fedOption) {
-    const imports = sharedInfo.reduce((acc, cur) => {
+    const imports = sharedInfo.externals.reduce((acc, cur) => {
         return {
             ...acc,
             [cur.packageName]: cur.outFileName,
         };
     }, {});
+    if (sharedInfo.chunks) {
+        Object.values(sharedInfo.chunks).forEach(c => {
+            c.forEach(e => {
+                const key = toChunkImport(e);
+                imports[key] = e;
+            });
+        });
+    }
     const importMap = { imports };
     const importMapPath = path.join(fedOption.workspaceRoot, fedOption.outputPath, 'importmap.json');
     fs.writeFileSync(importMapPath, JSON.stringify(importMap, null, 2));

package/src/lib/domain/config/external-config.contract.d.ts

@@ -5,7 +5,9 @@ export interface ExternalConfig {
     version?: string;
     includeSecondaries?: boolean;
     platform?: 'browser' | 'node';
-    build?: 'default' | 'separate';
+    build?: 'separate' | 'package';
+    chunks?: boolean;
+    shareScope?: string;
     packageInfo?: {
         entryPoint: string;
         version?: string;
@@ -18,6 +20,8 @@ export interface NormalizedExternalConfig {
     requiredVersion: string;
     version?: string;
     includeSecondaries?: boolean;
+    shareScope?: string;
+    chunks: boolean;
     platform: 'browser' | 'node';
     build: 'default' | 'separate' | 'package';
     packageInfo?: {
@@ -37,4 +41,3 @@ export type ShareAllExternalsOptions = ExternalConfig & {
     includeSecondaries?: IncludeSecondariesOptions;
 };
 export type ShareExternalsOptions = Record<string, ShareAllExternalsOptions>;
-//# sourceMappingURL=external-config.contract.d.ts.map

package/src/lib/domain/config/federation-config.contract.d.ts

@@ -1,28 +1,35 @@
 import type { PreparedSkipList, SkipList } from './skip-list.contract.js';
-import type { MappedPath } from '../utils/mapped-path.contract.js';
+import type { PathToImport } from '../utils/mapped-path.contract.js';
 import type { NormalizedSharedExternalsConfig, SharedExternalsConfig } from './external-config.contract.js';
 export interface FederationConfig {
     name?: string;
     exposes?: Record<string, string>;
     shared?: SharedExternalsConfig;
+    platform?: 'browser' | 'node';
     sharedMappings?: Array<string>;
+    chunks?: boolean;
     skip?: SkipList;
     externals?: string[];
+    shareScope?: string;
     features?: {
         mappingVersion?: boolean;
         ignoreUnusedDeps?: boolean;
+        denseChunking?: boolean;
     };
 }
 export interface NormalizedFederationConfig {
+    $type: 'classic';
     name: string;
     exposes: Record<string, string>;
     shared: NormalizedSharedExternalsConfig;
-    sharedMappings: Array<MappedPath>;
+    sharedMappings: PathToImport;
     skip: PreparedSkipList;
+    chunks: boolean;
     externals: string[];
+    shareScope?: string;
     features: {
         mappingVersion: boolean;
         ignoreUnusedDeps: boolean;
+        denseChunking: boolean;
     };
 }
-//# sourceMappingURL=federation-config.contract.d.ts.map