@softarc/native-federation 4.0.0-RC8 → 4.0.0

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,58 @@
+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),
+        cacheExternalArtifacts: options.cacheExternalArtifacts ?? true,
+        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.js

@@ -5,10 +5,10 @@ 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();
-    // Shared mappings and exposed modules
     const artifactInfo = await bundleExposedAndMappings(config, fedOptions, externals, modifiedFiles, signal);
-    logger.measure(start, '[build artifacts] - To re-bundle all mappings and exposed.');
+    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;

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

@@ -5,7 +5,8 @@ export interface ExternalConfig {
     version?: string;
     includeSecondaries?: boolean;
     platform?: 'browser' | 'node';
-    build?: 'default' | 'separate' | 'package';
+    build?: 'separate' | 'package';
+    chunks?: boolean;
     shareScope?: string;
     packageInfo?: {
         entryPoint: string;
@@ -20,6 +21,7 @@ export interface NormalizedExternalConfig {
     version?: string;
     includeSecondaries?: boolean;
     shareScope?: string;
+    chunks: boolean;
     platform: 'browser' | 'node';
     build: 'default' | 'separate' | 'package';
     packageInfo?: {

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

@@ -1,29 +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;
     };
 }

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

@@ -0,0 +1,2 @@
+import type { NormalizedFederationConfig } from './federation-config.contract.js';
+export type WithNativeFederation = NormalizedFederationConfig;

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,9 +1,16 @@
-import type { MappedPath } from '../utils/mapped-path.contract.js';
+import type { PathToImport } from '../utils/mapped-path.contract.js';
 import type { FederationCache } from './federation-cache.contract.js';
+export interface NFBuildAdapterContext<TBundlerContext = unknown> {
+    ctx: TBundlerContext;
+    outdir: string;
+    dev: boolean;
+    name: string;
+    isMappingOrExposed: boolean;
+}
 export interface NFBuildAdapter {
-    setup(options: NFBuildAdapterOptions): Promise<void>;
+    setup(name: string, options: NFBuildAdapterOptions): Promise<void>;
     build(name: string, opts?: {
-        files?: string[];
+        modifiedFiles?: string[];
         signal?: AbortSignal;
     }): Promise<NFBuildAdapterResult[]>;
     dispose(name?: string): Promise<void>;
@@ -18,9 +25,8 @@ export interface NFBuildAdapterOptions<TBundlerCache = unknown> {
     tsConfigPath?: string;
     external: string[];
     outdir: string;
-    mappedPaths: MappedPath[];
-    bundleName: string;
-    isNodeModules: boolean;
+    mappedPaths: PathToImport;
+    isMappingOrExposed: boolean;
     dev?: boolean;
     watch?: boolean;
     chunks?: boolean;

package/src/lib/domain/core/federation-options.contract.d.ts

@@ -4,19 +4,19 @@ export interface FederationOptions {
     workspaceRoot: string;
     outputPath: string;
     federationConfig: string;
+    projectName?: string;
     cacheExternalArtifacts?: boolean;
-    chunks?: boolean | {
-        enable: boolean;
-        dense?: boolean;
-    };
     tsConfig?: string;
     verbose?: boolean;
     dev?: boolean;
     watch?: boolean;
     packageJson?: string;
-    entryPoint?: string;
+    entryPoints?: string[];
     buildNotifications?: BuildNotificationOptions;
 }
 export interface NormalizedFederationOptions<TBundlerCache = unknown> extends FederationOptions {
     federationCache: FederationCache<TBundlerCache>;
+    entryPoints: string[];
+    projectName: string;
+    cacheExternalArtifacts: boolean;
 }

package/src/lib/domain/core/index.d.ts

@@ -1,6 +1,6 @@
 export type { SharedInfo, FederationInfo, ExposesInfo, ArtifactInfo, ChunkInfo, } from './federation-info.contract.js';
 export { type BuildNotificationOptions, BuildNotificationType, } from './build-notification-options.contract.js';
 export type { FederationOptions, NormalizedFederationOptions, } from './federation-options.contract.js';
-export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, } from './build-adapter.contract.js';
+export type { EntryPoint, NFBuildAdapterOptions, NFBuildAdapter, NFBuildAdapterResult, NFBuildAdapterContext, } from './build-adapter.contract.js';
 export { CHUNK_PREFIX, toChunkImport } from './chunk.js';
 export type { FederationCache } from './federation-cache.contract.js';

package/src/lib/domain/utils/file-watcher.contract.d.ts

@@ -0,0 +1,10 @@
+export interface NfFileWatcherOptions {
+    onChange?: (path: string) => void;
+}
+export interface NfFileWatcher {
+    addPaths(paths: string | readonly string[]): void;
+    close(): Promise<void>;
+    get(): ReadonlySet<string>;
+    clear(): void;
+    mutate(fn: (dirtyPaths: Set<string>) => void): void;
+}

package/src/lib/domain/utils/file-watcher.contract.js

@@ -0,0 +1 @@
+export {};

package/src/lib/domain/utils/index.d.ts

@@ -1,2 +1,2 @@
 export type { KeyValuePair } from './keyvaluepair.contract.js';
-export type { MappedPath } from './mapped-path.contract.js';
+export type { PathToImport } from './mapped-path.contract.js';

package/src/lib/domain/utils/mapped-path.contract.d.ts

@@ -1,4 +1 @@
-export interface MappedPath {
-    key: string;
-    path: string;
-}
+export type PathToImport = Record<string, string>;

package/src/lib/domain/utils/mapped-path.contract.js

@@ -1 +1,5 @@
+// export interface MappedPath {
+//   key: string;
+//   path: string;
+// }
 export {};

package/src/lib/domain/utils/used-dependencies.contract.d.ts

@@ -0,0 +1,5 @@
+import type { PathToImport } from './mapped-path.contract.js';
+export type UsedDependencies = {
+    external: Set<string>;
+    internal: PathToImport;
+};

package/src/lib/domain/utils/used-dependencies.contract.js

@@ -0,0 +1 @@
+export {};

package/src/lib/utils/file-watcher.d.ts

@@ -0,0 +1,5 @@
+import type { NfFileWatcher, NfFileWatcherOptions } from '../domain/utils/file-watcher.contract.js';
+export declare function createNfWatcher(options?: NfFileWatcherOptions): NfFileWatcher;
+export declare function syncNfFileWatcher(watcher: NfFileWatcher, bundlerCache: {
+    keys(): IterableIterator<string>;
+}): void;

package/src/lib/utils/file-watcher.js

@@ -0,0 +1,51 @@
+import { logger } from '@softarc/native-federation/internal';
+import { watch, statSync } from 'fs';
+import { join } from 'path';
+const toUnix = (p) => p.replace(/\\/g, '/');
+export function createNfWatcher(options = {}) {
+    const { onChange } = options;
+    const watchers = new Map();
+    const dirtyPaths = new Set();
+    const notify = (path) => {
+        if (onChange)
+            onChange(path);
+        else
+            dirtyPaths.add(path);
+    };
+    return {
+        addPaths(paths) {
+            const list = typeof paths === 'string' ? [paths] : [...paths];
+            for (const p of list) {
+                if (watchers.has(p))
+                    continue;
+                try {
+                    const isDir = statSync(p).isDirectory();
+                    const w = isDir
+                        ? watch(p, { recursive: true }, (_, filename) => {
+                            if (filename)
+                                notify(toUnix(join(p, filename)));
+                        })
+                        : watch(p, () => notify(toUnix(p)));
+                    watchers.set(p, w);
+                }
+                catch {
+                    logger.debug(`Could not watch path '${p}'.`);
+                }
+            }
+        },
+        get: () => dirtyPaths,
+        clear: () => dirtyPaths.clear(),
+        mutate: fn => fn(dirtyPaths),
+        async close() {
+            for (const w of watchers.values()) {
+                w.close();
+            }
+            watchers.clear();
+        },
+    };
+}
+export function syncNfFileWatcher(watcher, bundlerCache) {
+    const files = [...bundlerCache.keys()].filter(k => !k.includes('node_modules'));
+    if (files.length)
+        watcher.addPaths(files);
+}

package/src/lib/utils/get-used-dependencies.d.ts

@@ -0,0 +1,7 @@
+import { type PathToImport } from '../domain/utils/mapped-path.contract.js';
+import { type UsedDependencies } from '../domain/utils/used-dependencies.contract.js';
+export declare function getUsedDependenciesFactory(workspaceRoot: string, fallbackEntryPoints?: string[]): (config: {
+    name?: string;
+    exposes?: Record<string, string>;
+    sharedMappings: PathToImport;
+}) => UsedDependencies;

package/src/lib/utils/get-used-dependencies.js

@@ -0,0 +1,123 @@
+import { getProjectData } from '@softarc/sheriff-core';
+import { cwd } from 'process';
+import { getPackageInfo } from './package-info.js';
+import { getExternalImports as extractExternalImports } from './get-external-imports.js';
+import * as path from 'path';
+export function getUsedDependenciesFactory(workspaceRoot, fallbackEntryPoints) {
+    return config => {
+        let entryPoints = Object.values(config.exposes ?? {});
+        if (entryPoints.length < 1)
+            entryPoints = fallbackEntryPoints;
+        if (!entryPoints || entryPoints.length < 1)
+            throw new Error('[removeUnusedDeps] native-federation is missing an entryPoint! You can set it using the Federation options or by setting an exposed module in the Federation config file.');
+        const fileInfos = Object.values(entryPoints ?? []).reduce((acc, entryPoint) => ({
+            ...acc,
+            ...getProjectData(entryPoint, cwd(), {
+                includeExternalLibraries: true,
+            }),
+        }), {});
+        const usedPackageNames = new Set();
+        for (const fileInfo of Object.values(fileInfos)) {
+            for (const pckg of [
+                ...(fileInfo?.externalLibraries || []),
+                ...(fileInfo?.unresolvedImports || []),
+            ]) {
+                usedPackageNames.add(pckg);
+            }
+        }
+        return {
+            external: addTransientDeps(usedPackageNames, workspaceRoot),
+            internal: resolveUsedMappings(fileInfos, workspaceRoot, config.sharedMappings),
+        };
+    };
+}
+function addTransientDeps(packages, workspaceRoot) {
+    const packagesAndPeers = new Set([...packages]);
+    const discovered = new Set(packagesAndPeers);
+    const stack = [...packagesAndPeers];
+    while (stack.length > 0) {
+        const dep = stack.pop();
+        if (!dep) {
+            continue;
+        }
+        const pInfo = getPackageInfo(dep, workspaceRoot);
+        if (!pInfo) {
+            continue;
+        }
+        const peerDeps = extractExternalImports(pInfo.entryPoint);
+        for (const peerDep of peerDeps) {
+            if (!discovered.has(peerDep)) {
+                discovered.add(peerDep);
+                stack.push(peerDep);
+                packagesAndPeers.add(peerDep);
+            }
+        }
+    }
+    return packagesAndPeers;
+}
+function resolveUsedMappings(fileInfos, workspaceRoot, sharedMappings) {
+    const usedMappings = {};
+    for (const fileName of Object.keys(fileInfos)) {
+        const fullFileName = path.join(workspaceRoot, fileName);
+        if (isSharedMapping(fullFileName, sharedMappings))
+            continue;
+        const fileInfo = fileInfos[fileName];
+        if (!fileInfo)
+            continue;
+        // Check if any of this file's imports land in a shared mapping
+        for (const imp of fileInfo.imports ?? []) {
+            const fullImport = path.join(workspaceRoot, imp);
+            const match = matchMapping(fullImport, sharedMappings);
+            if (match)
+                usedMappings[fullImport] = match;
+        }
+    }
+    return usedMappings;
+}
+function isSharedMapping(filePath, sharedMappings) {
+    for (const sharedPath of Object.keys(sharedMappings)) {
+        const asteriskIndex = sharedPath.indexOf('*');
+        if (asteriskIndex !== -1) {
+            const prefix = sharedPath.substring(0, asteriskIndex);
+            if (filePath.startsWith(prefix))
+                return true;
+        }
+        else if (filePath.startsWith(sharedPath + path.sep) || filePath === sharedPath) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchMapping(filePath, sharedMappings) {
+    for (const [sharedPath, sharedImport] of Object.entries(sharedMappings)) {
+        const asteriskIndex = sharedPath.indexOf('*');
+        if (asteriskIndex !== -1) {
+            const prefix = sharedPath.substring(0, asteriskIndex);
+            const suffix = sharedPath.substring(asteriskIndex + 1);
+            if (!filePath.startsWith(prefix))
+                continue;
+            if (suffix && !filePath.includes(suffix))
+                continue;
+            const captured = suffix
+                ? filePath.slice(prefix.length, filePath.indexOf(suffix, prefix.length))
+                : filePath.slice(prefix.length);
+            return sharedImport.replace('*', toImportPath(captured));
+        }
+        else if (filePath === sharedPath || isIndexOf(filePath, sharedPath)) {
+            return sharedImport;
+        }
+    }
+    return null;
+}
+/**
+ * Detect if it's a barrel file which is inferred by typescript
+ */
+const INDEX_PATTERN = /\/index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+function isIndexOf(filePath, dirPath) {
+    return filePath.startsWith(dirPath + path.sep) && INDEX_PATTERN.test(filePath);
+}
+function toImportPath(filePath) {
+    const withoutExt = filePath.replace(/\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/, '');
+    const normalized = withoutExt.replace(/\\/g, '/');
+    return normalized.endsWith('/index') ? normalized.slice(0, -6) : normalized;
+}

package/src/lib/utils/mapped-paths.d.ts

@@ -1,7 +1,7 @@
-import type { MappedPath } from '../domain/utils/mapped-path.contract.js';
-export interface GetMappedPathsOptions {
-    rootTsConfigPath: string;
-    sharedMappings?: string[];
-    rootPath?: string;
-}
-export declare function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }: GetMappedPathsOptions): Array<MappedPath>;
+import type { PathToImport } from '../domain/utils/mapped-path.contract.js';
+/**
+ * Will return user defined and tsconfig defined paths including their imports, might contain wildcards
+ * @param param0
+ * @returns
+ */
+export declare function getRawMappedPaths(rootTsConfigPath: string, configuredSharedMappings?: string[], rootPath?: string): PathToImport;

package/src/lib/utils/mapped-paths.js

@@ -1,31 +1,33 @@
 import * as path from 'path';
 import * as fs from 'fs';
 import JSON5 from 'json5';
-export function getMappedPaths({ rootTsConfigPath, sharedMappings, rootPath, }) {
-    const result = [];
+/**
+ * Will return user defined and tsconfig defined paths including their imports, might contain wildcards
+ * @param param0
+ * @returns
+ */
+export function getRawMappedPaths(rootTsConfigPath, configuredSharedMappings, rootPath) {
+    const mappedPaths = {};
     if (!path.isAbsolute(rootTsConfigPath)) {
         throw new Error('SharedMappings.register: tsConfigPath needs to be an absolute path!');
     }
     if (!rootPath) {
         rootPath = path.normalize(path.dirname(rootTsConfigPath));
     }
-    const shareAll = !sharedMappings;
-    if (!sharedMappings) {
-        sharedMappings = [];
+    const shareAll = !configuredSharedMappings;
+    if (!configuredSharedMappings) {
+        configuredSharedMappings = [];
     }
     const tsConfig = JSON5.parse(fs.readFileSync(rootTsConfigPath, { encoding: 'utf-8' }));
     const mappings = tsConfig?.compilerOptions?.paths;
     if (!mappings) {
-        return result;
+        return mappedPaths;
     }
     for (const key in mappings) {
         const libPath = path.normalize(path.join(rootPath, mappings[key][0]));
-        if (sharedMappings.includes(key) || shareAll) {
-            result.push({
-                key,
-                path: libPath,
-            });
+        if (configuredSharedMappings.includes(key) || shareAll) {
+            mappedPaths[libPath] = key;
         }
     }
-    return result;
+    return mappedPaths;
 }

package/src/lib/utils/resolve-wildcard-keys.d.ts

@@ -1,2 +1,29 @@
-import type { KeyValuePair } from '../domain/utils/keyvaluepair.contract.js';
-export declare function resolveWildcardKeys(keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];
+export type KeyValuePair = {
+    key: string;
+    value: string;
+};
+/**
+ * Resolves tsconfig wildcard paths.
+ *
+ * In tsconfig.json, paths like `@features/*` → `libs/features/src/*` work as follows:
+ * - The `*` captures a single path segment (the module name)
+ * - When importing `@features/feature-a`, TypeScript captures `feature-a`
+ * - It then replaces `*` in the value pattern: `libs/features/src/feature-a`
+ *
+ * For discovery, we find all directories at the wildcard position that TypeScript
+ * would recognize as valid modules (directories with index files or package.json).
+ *
+// @see https://www.typescriptlang.org/docs/handbook/modules/theory.html#module-resolution
+ */
+export declare function resolveTsConfigWildcard(keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];
+/**
+ * Resolves package.json exports wildcard patterns.
+ *
+ * In package.json exports, patterns like `./features/*.js` → `./src/features/*.js` work as follows:
+ * - The `*` is a literal string replacement that can include path separators
+ * - Importing `pkg/features/a/b.js` captures `a/b` and replaces `*` → `./src/features/a/b.js`
+ * - This matches actual files, not directories
+ *
+ * @see https://nodejs.org/api/packages.html#subpath-patterns
+ */
+export declare function resolvePackageJsonExportsWildcard(keyPattern: string, valuePattern: string, cwd: string): KeyValuePair[];