@softarc/native-federation 3.5.5 → 4.0.0-RC10

package/src/lib/config/with-native-federation.js

@@ -1,97 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withNativeFederation = withNativeFederation;
-const mapped_paths_1 = require("../utils/mapped-paths");
-const share_utils_1 = require("./share-utils");
-const default_skip_list_1 = require("../core/default-skip-list");
-const logger_1 = require("../utils/logger");
-const default_server_deps_list_1 = require("../core/default-server-deps-list");
-function withNativeFederation(config) {
-    const skip = (0, default_skip_list_1.prepareSkipList)(config.skip ?? []);
+import { getRawMappedPaths } from '../utils/mapped-paths.js';
+import { shareAll, findRootTsConfigJson } from './share-utils.js';
+import { isInSkipList, prepareSkipList } from './default-skip-list.js';
+import { logger } from '../utils/logger.js';
+export function withNativeFederation(config) {
+    const skip = prepareSkipList(config.skip ?? []);
+    const chunks = config.chunks ?? true;
     const normalized = {
+        $type: 'classic',
         name: config.name ?? '',
         exposes: config.exposes ?? {},
-        shared: normalizeShared(config, skip),
-        sharedMappings: normalizeSharedMappings(config, skip),
+        shared: normalizeShared(config, skip, chunks),
+        sharedMappings: removeSkippedMappings(config, skip),
+        chunks,
         skip,
         externals: config.externals ?? [],
         features: {
             mappingVersion: config.features?.mappingVersion ?? false,
-            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? false,
+            ignoreUnusedDeps: config.features?.ignoreUnusedDeps ?? true,
+            denseChunking: config.features?.denseChunking ?? false,
         },
+        ...(config.shareScope && { shareScope: config.shareScope }),
     };
-    // This is for being backwards compatible
-    if (!normalized.features.ignoreUnusedDeps) {
-        normalized.shared = filterShared(normalized.shared);
-    }
     return normalized;
 }
-function filterShared(shared) {
-    const keys = Object.keys(shared).filter((k) => !k.startsWith('@angular/common/locales'));
-    const filtered = keys.reduce((acc, curr) => ({
-        ...acc,
-        [curr]: shared[curr],
-    }), {});
-    return filtered;
-}
-function normalizeShared(config, skip) {
+function normalizeShared(config, skip, chunks) {
     let result = {};
-    const shared = config.shared;
-    if (!shared) {
-        result = (0, share_utils_1.shareAll)({
+    const shared = config.shared ??
+        shareAll({
             singleton: true,
             strictVersion: true,
             requiredVersion: 'auto',
             platform: 'browser',
         });
-    }
-    else {
-        result = Object.keys(shared).reduce((acc, cur) => ({
+    result = Object.keys(shared).reduce((acc, cur) => {
+        const key = cur.replace(/\\/g, '/');
+        const sharedConfig = shared[cur];
+        if (!!sharedConfig.chunks && !sharedConfig.build && sharedConfig.chunks !== chunks) {
+            logger.warn(`External '${cur}' has explicit chunk settings, consider switching build type to { build: 'package' }.`);
+            sharedConfig.chunks = chunks;
+        }
+        const normalizedConfig = {
+            requiredVersion: sharedConfig.requiredVersion ?? 'auto',
+            singleton: sharedConfig.singleton ?? false,
+            strictVersion: sharedConfig.strictVersion ?? false,
+            version: sharedConfig.version,
+            chunks: sharedConfig.chunks ?? chunks,
+            includeSecondaries: sharedConfig.includeSecondaries,
+            packageInfo: sharedConfig.packageInfo,
+            platform: sharedConfig.platform ?? config.platform ?? 'browser',
+            build: sharedConfig.build ?? 'default',
+            ...(sharedConfig.shareScope && { shareScope: sharedConfig.shareScope }),
+        };
+        return {
             ...acc,
-            [cur.replace(/\\/g, '/')]: {
-                requiredVersion: shared[cur].requiredVersion ?? 'auto',
-                singleton: shared[cur].singleton ?? false,
-                strictVersion: shared[cur].strictVersion ?? false,
-                version: shared[cur].version,
-                includeSecondaries: shared[cur].includeSecondaries,
-                packageInfo: shared[cur].packageInfo,
-                platform: shared[cur].platform ?? getDefaultPlatform(cur),
-                build: shared[cur].build ?? 'default',
-            },
-        }), {});
-        //result = share(result) as Record<string, NormalizedSharedConfig>;
-    }
+            [key]: normalizedConfig,
+        };
+    }, {});
     result = Object.keys(result)
-        .filter((key) => !(0, default_skip_list_1.isInSkipList)(key, skip))
-        .reduce((acc, cur) => ({
-        ...acc,
-        [cur]: result[cur],
-    }), {});
-    return result;
-}
-function normalizeSharedMappings(config, skipList) {
-    const rootTsConfigPath = (0, share_utils_1.findRootTsConfigJson)();
-    const paths = (0, mapped_paths_1.getMappedPaths)({
-        rootTsConfigPath,
-        sharedMappings: config.sharedMappings,
-    });
-    const result = paths.filter((p) => !(0, default_skip_list_1.isInSkipList)(p.key, skipList));
-    const importsWithDot = paths.filter((p) => p.key.includes('.'));
-    if (importsWithDot.length > 0) {
-        importsWithDot.forEach((e) => {
-            logger_1.logger.warn(`Shared mapping import '${e}' contains a dot.`);
-        });
-        logger_1.logger.warn('details: https://github.com/vitejs/vite/issues/21036');
-        throw new Error('Native-federation does not support dots (.) in imports paths. ');
-    }
+        .filter(key => !isInSkipList(key, skip))
+        .reduce((acc, cur) => ({ ...acc, [cur]: result[cur] }), {});
     return result;
 }
-function getDefaultPlatform(cur) {
-    if (default_server_deps_list_1.DEFAULT_SERVER_DEPS_LIST.find((e) => cur.startsWith(e))) {
-        return 'node';
-    }
-    else {
-        return 'browser';
-    }
+function removeSkippedMappings(config, skipList) {
+    const rootTsConfigPath = findRootTsConfigJson();
+    const paths = getRawMappedPaths(rootTsConfigPath, config.sharedMappings);
+    return Object.entries(paths)
+        .filter(([, _import]) => !isInSkipList(_import, skipList))
+        .reduce((acc, [_path, _import]) => ({ ...acc, [_path]: _import }), {});
 }
-//# sourceMappingURL=with-native-federation.js.map

package/src/lib/core/build-adapter.d.ts

@@ -1,28 +1,3 @@
-import { MappedPath } from '../utils/mapped-paths';
-export type BuildKind = 'shared-package' | 'shared-mapping' | 'exposed' | 'mapping-or-exposed';
-export interface EntryPoint {
-    fileName: string;
-    outName: string;
-}
-export interface BuildAdapterOptions {
-    entryPoints: EntryPoint[];
-    tsConfigPath?: string;
-    external: Array<string>;
-    outdir: string;
-    mappedPaths: MappedPath[];
-    packageName?: string;
-    esm?: boolean;
-    dev?: boolean;
-    watch?: boolean;
-    kind: BuildKind;
-    hash: boolean;
-    platform?: 'browser' | 'node';
-    optimizedMappings?: boolean;
-    signal?: AbortSignal;
-}
-export interface BuildResult {
-    fileName: string;
-}
-export type BuildAdapter = (options: BuildAdapterOptions) => Promise<BuildResult[]>;
-export declare function setBuildAdapter(buildAdapter: BuildAdapter): void;
-export declare function getBuildAdapter(): BuildAdapter;
+import type { NFBuildAdapter } from '../domain/core/build-adapter.contract.js';
+export declare function setBuildAdapter(buildAdapter: NFBuildAdapter): void;
+export declare function getBuildAdapter(): NFBuildAdapter;

package/src/lib/core/build-adapter.js

@@ -1,17 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setBuildAdapter = setBuildAdapter;
-exports.getBuildAdapter = getBuildAdapter;
-const logger_1 = require("../utils/logger");
-let _buildAdapter = async () => {
-    // TODO: add logger
-    logger_1.logger.error('Please set a BuildAdapter!');
-    return [];
-};
-function setBuildAdapter(buildAdapter) {
+import { logger } from '../utils/logger.js';
+let _buildAdapter = null;
+export function setBuildAdapter(buildAdapter) {
     _buildAdapter = buildAdapter;
 }
-function getBuildAdapter() {
+export function getBuildAdapter() {
+    if (!_buildAdapter) {
+        logger.error('Please set a BuildAdapter!');
+        throw new Error('BuildAdapter not set');
+    }
     return _buildAdapter;
 }
-//# sourceMappingURL=build-adapter.js.map

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

@@ -1,10 +1,4 @@
-import { FederationInfo } from '@softarc/native-federation-runtime';
-import { NormalizedFederationConfig } from '../config/federation-config';
-import { FederationOptions } from './federation-options';
-export interface BuildParams {
-    skipMappingsAndExposed: boolean;
-    skipShared: boolean;
-    signal?: AbortSignal;
-}
-export declare const defaultBuildParams: BuildParams;
-export declare function buildForFederation(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], buildParams?: BuildParams): Promise<FederationInfo>;
+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 buildForFederation(config: NormalizedFederationConfig, fedOptions: NormalizedFederationOptions, externals: string[], signal?: AbortSignal): Promise<FederationInfo>;

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

@@ -1,93 +1,94 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultBuildParams = void 0;
-exports.buildForFederation = buildForFederation;
-const bundle_exposed_and_mappings_1 = require("./bundle-exposed-and-mappings");
-const bundle_shared_1 = require("./bundle-shared");
-const write_federation_info_1 = require("./write-federation-info");
-const write_import_map_1 = require("./write-import-map");
-const logger_1 = require("../utils/logger");
-const bundle_caching_1 = require("./../utils/bundle-caching");
-const normalize_1 = require("../utils/normalize");
-const errors_1 = require("../utils/errors");
-const config_utils_1 = require("../utils/config-utils");
-exports.defaultBuildParams = {
-    skipMappingsAndExposed: false,
-    skipShared: false,
-};
-const sharedPackageInfoCache = [];
-async function buildForFederation(config, fedOptions, externals, buildParams = exports.defaultBuildParams) {
-    const signal = buildParams.signal;
-    let artefactInfo;
-    if (!buildParams.skipMappingsAndExposed) {
-        const start = process.hrtime();
-        artefactInfo = await (0, bundle_exposed_and_mappings_1.bundleExposedAndMappings)(config, fedOptions, externals, signal);
-        logger_1.logger.measure(start, '[build artifacts] - To bundle all mappings and exposed.');
-        if (signal?.aborted)
-            throw new errors_1.AbortedError('[buildForFederation] After exposed-and-mappings bundle');
-    }
-    const exposedInfo = !artefactInfo
-        ? (0, bundle_exposed_and_mappings_1.describeExposed)(config, fedOptions)
-        : artefactInfo.exposes;
-    const cacheProjectFolder = (0, config_utils_1.resolveProjectName)(config);
-    const pathToCache = (0, bundle_caching_1.getCachePath)(fedOptions.workspaceRoot, cacheProjectFolder);
-    if (!buildParams.skipShared && sharedPackageInfoCache.length > 0) {
-        logger_1.logger.info('Checksum matched, re-using cached externals.');
+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 (!buildParams.skipShared && sharedPackageInfoCache.length === 0) {
+    if (fedOptions.federationCache.externals.length === 0) {
         const { sharedBrowser, sharedServer, separateBrowser, separateServer } = splitShared(config.shared);
         if (Object.keys(sharedBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoBrowser = await (0, bundle_shared_1.bundleShared)(sharedBrowser, config, fedOptions, externals, 'browser', { pathToCache, bundleName: 'browser-shared' });
-            logger_1.logger.measure(start, '[build artifacts] - To bundle all shared browser externals');
-            sharedPackageInfoCache.push(...sharedPackageInfoBrowser);
+            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 errors_1.AbortedError('[buildForFederation] After shared-browser bundle');
+                throw new AbortedError('[buildForFederation] After shared-browser bundle');
         }
         if (Object.keys(sharedServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'server-shared'`);
             const start = process.hrtime();
-            const sharedPackageInfoServer = await (0, bundle_shared_1.bundleShared)(sharedServer, config, fedOptions, externals, 'node', { pathToCache, bundleName: 'node-shared' });
-            logger_1.logger.measure(start, '[build artifacts] - To bundle all shared node externals');
-            sharedPackageInfoCache.push(...sharedPackageInfoServer);
+            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 errors_1.AbortedError('[buildForFederation] After shared-node bundle');
+                throw new AbortedError('[buildForFederation] After shared-node bundle');
         }
         if (Object.keys(separateBrowser).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'browser-separate'`);
             const start = process.hrtime();
-            const separatePackageInfoBrowser = await bundleSeparatePackages(separateBrowser, externals, config, fedOptions, 'browser', pathToCache);
-            logger_1.logger.measure(start, '[build artifacts] - To bundle all separate browser externals');
-            sharedPackageInfoCache.push(...separatePackageInfoBrowser);
+            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 errors_1.AbortedError('[buildForFederation] After separate-browser bundle');
+                throw new AbortedError('[buildForFederation] After separate-browser bundle');
         }
         if (Object.keys(separateServer).length > 0) {
-            notifyBundling('browser-shared');
+            logger.info(`Bundling external npm packages with bundle type 'node-separate'`);
             const start = process.hrtime();
-            const separatePackageInfoServer = await bundleSeparatePackages(separateServer, externals, config, fedOptions, 'node', pathToCache);
-            logger_1.logger.measure(start, '[build artifacts] - To bundle all separate node externals');
-            sharedPackageInfoCache.push(...separatePackageInfoServer);
+            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 errors_1.AbortedError('[buildForFederation] After separate-node bundle');
+            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 sharedMappingInfo = !artefactInfo
-        ? (0, bundle_exposed_and_mappings_1.describeSharedMappings)(config, fedOptions)
-        : artefactInfo.mappings;
-    const sharedInfo = [...sharedPackageInfoCache, ...sharedMappingInfo];
     const buildNotificationsEndpoint = fedOptions.buildNotifications?.enable && fedOptions.dev
         ? fedOptions.buildNotifications?.endpoint
         : undefined;
     const federationInfo = {
         name: config.name,
-        shared: sharedInfo,
+        shared: sharedExternals,
         exposes: exposedInfo,
         buildNotificationsEndpoint,
     };
-    (0, write_federation_info_1.writeFederationInfo)(federationInfo, fedOptions);
-    (0, write_import_map_1.writeImportMap)(sharedInfo, fedOptions);
+    if (fedOptions.federationCache.chunks) {
+        federationInfo.chunks = fedOptions.federationCache.chunks;
+    }
+    if (artifactInfo?.chunks) {
+        federationInfo.chunks = { ...(federationInfo.chunks ?? {}), ...artifactInfo?.chunks };
+    }
+    writeFederationInfo(federationInfo, fedOptions);
+    writeImportMap(fedOptions.federationCache, fedOptions);
     return federationInfo;
 }
 function inferPackageFromSecondary(secondary) {
@@ -97,28 +98,33 @@ function inferPackageFromSecondary(secondary) {
     }
     return parts[0];
 }
-async function bundleSeparatePackages(separateBrowser, externals, config, fedOptions, platform, pathToCache) {
+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] = {};
+            groupedByPackage[packageName] = {
+                chunks: shared.chunks,
+                entries: {},
+            };
         }
-        groupedByPackage[packageName][key] = shared;
+        groupedByPackage[packageName].entries[key] = shared;
     }
-    const bundlePromises = Object.entries(groupedByPackage).map(async ([packageName, sharedGroup]) => {
-        return (0, bundle_shared_1.bundleShared)(sharedGroup, config, fedOptions, externals.filter((e) => !e.startsWith(packageName)), platform, {
-            pathToCache,
-            bundleName: `${platform}-${(0, normalize_1.normalizePackageName)(packageName)}`,
+    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.flat();
-}
-function notifyBundling(platform) {
-    logger_1.logger.info('Preparing shared npm packages for the platform ' + platform);
-    logger_1.logger.notice('This only needs to be done once, as results are cached');
-    logger_1.logger.notice("Skip packages you don't want to share in your federation config");
+    return buildResults.reduce((acc, r) => {
+        let chunks = acc.chunks;
+        if (r.chunks) {
+            chunks = { ...(acc.chunks ?? {}), ...r.chunks };
+        }
+        return { externals: [...acc.externals, ...r.externals], chunks };
+    }, { externals: [] });
 }
 function splitShared(shared) {
     const sharedServer = {};
@@ -127,7 +133,7 @@ function splitShared(shared) {
     const separateServer = {};
     for (const key in shared) {
         const obj = shared[key];
-        if (obj.platform === 'node') {
+        if (obj?.platform === 'node') {
             if (obj.build === 'default') {
                 sharedServer[key] = obj;
             }
@@ -135,7 +141,7 @@ function splitShared(shared) {
                 separateServer[key] = obj;
             }
         }
-        else if (obj.platform === 'browser') {
+        else if (obj?.platform === 'browser') {
             if (obj.build === 'default') {
                 sharedBrowser[key] = obj;
             }
@@ -151,4 +157,3 @@ function splitShared(shared) {
         separateServer,
     };
 }
-//# sourceMappingURL=build-for-federation.js.map

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

@@ -1,10 +1,6 @@
-import { ExposesInfo, SharedInfo } from '@softarc/native-federation-runtime';
-import { NormalizedFederationConfig } from '../config/federation-config';
-import { FederationOptions } from './federation-options';
-export interface ArtefactInfo {
-    mappings: SharedInfo[];
-    exposes: ExposesInfo[];
-}
-export declare function bundleExposedAndMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions, externals: string[], signal?: AbortSignal): Promise<ArtefactInfo>;
-export declare function describeExposed(config: NormalizedFederationConfig, options: FederationOptions): Array<ExposesInfo>;
-export declare function describeSharedMappings(config: NormalizedFederationConfig, fedOptions: FederationOptions): Array<SharedInfo>;
+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>;