@angular-architects/native-federation-v4 21.1.7 → 21.1.9

package/src/schematics/init/schematic.js

@@ -4,7 +4,7 @@ import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
 import { patchAngularBuildPackageJson, privateEntrySrc } from '../../utils/patch-angular-build.js';
 import { addPackageJsonDependency, getPackageJsonDependency, NodeDependencyType, } from '@schematics/angular/utility/dependencies';
 import * as path from 'path';
-const SSR_VERSION = '^3.3.4';
+const SSR_VERSION = '4.0.0-RC9';
 export function updatePackageJson(tree) {
     const packageJson = tree.readJson('package.json') ?? {};
     const scriptCall = 'node node_modules/@angular-architects/native-federation/src/patch-angular-build.js';
@@ -45,19 +45,7 @@ export default function config(options) {
             : noop;
         const ssr = isSsrProject(normalized);
         const server = ssr ? getSsrFilePath(normalized) : '';
-        if (ssr) {
-            console.log('SSR detected ...');
-            console.log('Activating CORS ...');
-            addPackageJsonDependency(tree, {
-                name: 'cors',
-                type: NodeDependencyType.Default,
-                version: '^2.8.5',
-                overwrite: false,
-            });
-        }
         updateWorkspaceConfig(tree, normalized, workspace, workspaceFileName, ssr);
-        // updatePackageJson(tree);
-        // patchAngularBuild(tree);
         addPackageJsonDependency(tree, {
             name: '@angular/animations',
             type: NodeDependencyType.Default,
@@ -77,12 +65,28 @@ export default function config(options) {
             overwrite: false,
         });
         addPackageJsonDependency(tree, {
-            name: '@softarc/native-federation-node',
+            name: '@softarc/native-federation-orchestrator',
             type: NodeDependencyType.Default,
-            version: SSR_VERSION,
-            overwrite: true,
+            version: '4.0.0-RC4',
+            overwrite: false,
         });
         context.addTask(new NodePackageInstallTask());
+        if (ssr) {
+            console.log('SSR detected ...');
+            console.log('Activating CORS ...');
+            addPackageJsonDependency(tree, {
+                name: 'cors',
+                type: NodeDependencyType.Default,
+                version: '^2.8.5',
+                overwrite: false,
+            });
+            addPackageJsonDependency(tree, {
+                name: '@softarc/native-federation-node',
+                type: NodeDependencyType.Default,
+                version: SSR_VERSION,
+                overwrite: true,
+            });
+        }
         return chain([
             generateRule,
             makeMainAsync(main, options, remoteMap, manifestRelPath),
@@ -113,7 +117,8 @@ export function patchAngularBuild(tree) {
     }
 }
 function updateWorkspaceConfig(tree, options, workspace, workspaceFileName, ssr) {
-    const { projectConfig, projectName, port } = options;
+    const { projectConfig, projectName, port, main, projectSourceRoot } = options;
+    const entryPoints = main ? [main] : [path.join(projectSourceRoot, 'main.ts')];
     if (!projectConfig?.architect?.build || !projectConfig?.architect?.serve) {
         throw new Error(`The project doesn't have a build or serve target in angular.json!`);
     }
@@ -134,7 +139,11 @@ function updateWorkspaceConfig(tree, options, workspace, workspaceFileName, ssr)
     projectConfig.architect.esbuild = originalBuild;
     projectConfig.architect.build = {
         builder: '@angular-architects/native-federation:build',
-        options: {},
+        options: {
+            projectName,
+            cacheExternalArtifacts: true,
+            entryPoints,
+        },
         configurations: {
             production: {
                 target: `${projectName}:esbuild:production`,
@@ -168,11 +177,14 @@ function updateWorkspaceConfig(tree, options, workspace, workspaceFileName, ssr)
     projectConfig.architect.serve = {
         builder: '@angular-architects/native-federation:build',
         options: {
+            projectName,
             target: `${projectName}:serve-original:development`,
             rebuildDelay: 500,
+            cacheExternalArtifacts: true,
             dev: true,
-            cacheExternalArtifacts: false,
+            devServer: true,
             port: 0,
+            entryPoints,
         },
     };
     const serveSsr = projectConfig.architect['serve-ssr'];
@@ -292,11 +304,24 @@ function makeMainAsync(main, options, remoteMap, manifestRelPath) {
         const mainContent = tree.read(main);
         if (mainContent)
             tree.create(bootstrapName, mainContent);
+        const orchestratorImports = `import { initFederation } from '@softarc/native-federation-orchestrator';
+import {
+  useShimImportMap,
+  consoleLogger,
+  globalThisStorageEntry,
+} from '@softarc/native-federation-orchestrator/options';`;
+        const orchestratorOptions = `{
+  ...useShimImportMap({ shimMode: true }),
+  logger: consoleLogger,
+  storage: globalThisStorageEntry,
+  hostRemoteEntry: './remoteEntry.json',
+  logLevel: 'debug',
+}`;
         let newMainContent = '';
         if (options.type === 'dynamic-host') {
-            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+            newMainContent = `${orchestratorImports}
 
-initFederation('${manifestRelPath}')
+initFederation('${manifestRelPath}', ${orchestratorOptions})
   .catch(err => console.error(err))
   .then(_ => import('./bootstrap'))
   .catch(err => console.error(err));
@@ -304,18 +329,18 @@ initFederation('${manifestRelPath}')
         }
         else if (options.type === 'host') {
             const manifest = JSON.stringify(remoteMap, null, 2).replace(/"/g, "'");
-            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+            newMainContent = `${orchestratorImports}
 
-initFederation(${manifest})
+initFederation(${manifest}, ${orchestratorOptions})
   .catch(err => console.error(err))
   .then(_ => import('./bootstrap'))
   .catch(err => console.error(err));
 `;
         }
         else {
-            newMainContent = `import { initFederation } from '@angular-architects/native-federation';
+            newMainContent = `${orchestratorImports}
 
-initFederation()
+initFederation({ '${options.project}': './remoteEntry.json' }, ${orchestratorOptions})
   .catch(err => console.error(err))
   .then(_ => import('./bootstrap'))
   .catch(err => console.error(err));

package/src/schematics/update-v4/schema.d.ts

@@ -0,0 +1,4 @@
+export interface UpdateV4Schema {
+  project: string;
+  orchestrator: boolean;
+}

package/src/schematics/update-v4/schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "update-v4",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The project to migrate to v4",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Project name (press enter for default project)"
+    },
+    "orchestrator": {
+      "type": "boolean",
+      "description": "Switch main.ts to use @softarc/native-federation-orchestrator instead of the legacy runtime",
+      "default": false,
+      "x-prompt": "Would you like to use the new orchestrator runtime? (recommended)"
+    }
+  }
+}

package/src/schematics/update-v4/schematic.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from '@angular-devkit/schematics';
+import type { UpdateV4Schema } from './schema.js';
+export default function updateV4(options: UpdateV4Schema): Rule;
+//# sourceMappingURL=schematic.d.ts.map

package/src/schematics/update-v4/schematic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schematic.d.ts","sourceRoot":"","sources":["../../../../src/schematics/update-v4/schematic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAQ,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAelD,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAgB9D"}

package/src/schematics/update-v4/schematic.js

@@ -0,0 +1,225 @@
+import { NodePackageInstallTask } from '@angular-devkit/schematics/tasks';
+import { getWorkspaceFileName } from '../init/schematic.js';
+import * as path from 'path';
+const V3_PACKAGE = '@angular-architects/native-federation';
+const V4_PACKAGE = '@angular-architects/native-federation-v4';
+const V3_BUILDER = `${V3_PACKAGE}:build`;
+const V4_BUILDER = `${V4_PACKAGE}:build`;
+const V3_RUNTIME_IMPORT = `@angular-architects/native-federation`;
+const V4_RUNTIME_IMPORT = `@softarc/native-federation-runtime`;
+const ORCHESTRATOR_PACKAGE = `@softarc/native-federation-orchestrator`;
+export default function updateV4(options) {
+    return async function (tree, context) {
+        const workspaceFileName = getWorkspaceFileName(tree);
+        const workspace = JSON.parse(tree.read(workspaceFileName)?.toString('utf8') ?? '{}');
+        enableEsmInPackageJson(tree);
+        updateBuilderReferences(tree, workspace, workspaceFileName);
+        migrateFederationConfigs(tree, workspace, options);
+        migrateMainTs(tree, workspace, options);
+        if (options.orchestrator) {
+            installOrchestratorPackage(tree);
+            migrateMainTsToOrchestrator(tree, workspace, options);
+            context.addTask(new NodePackageInstallTask());
+        }
+    };
+}
+/**
+ * Step 1: Add "type": "module" to the root package.json
+ */
+function enableEsmInPackageJson(tree) {
+    const packageJson = JSON.parse(tree.read('package.json')?.toString('utf8') ?? '{}');
+    if (packageJson.type === 'module') {
+        return;
+    }
+    packageJson.type = 'module';
+    tree.overwrite('package.json', JSON.stringify(packageJson, null, 2));
+    console.log('Updated package.json: added "type": "module"');
+}
+/**
+ * Step 2: Update all builder references in angular.json / workspace.json
+ * from @angular-architects/native-federation:build to @angular-architects/native-federation-v4:build
+ */
+function updateBuilderReferences(tree, workspace, workspaceFileName) {
+    let modified = false;
+    for (const projectName of Object.keys(workspace.projects ?? {})) {
+        const project = workspace.projects[projectName];
+        const architect = project?.architect ?? {};
+        const sourceRoot = (project?.sourceRoot ?? '').replace(/\\/g, '/');
+        for (const targetName of Object.keys(architect)) {
+            const target = architect[targetName];
+            if (target?.builder === V3_BUILDER) {
+                target.builder = V4_BUILDER;
+                modified = true;
+                console.log(`Updated builder for "${projectName}:${targetName}" to ${V4_BUILDER}`);
+            }
+            // Add entryPoints and projectName to NF builder targets if not already set
+            if ((target?.builder === V3_BUILDER || target?.builder === V4_BUILDER) &&
+                !target?.options?.entryPoints) {
+                target.options ??= {};
+                target.options.entryPoints = [path.join(sourceRoot, 'main.ts')];
+                if (!target.options.projectName) {
+                    target.options.projectName = projectName;
+                }
+                modified = true;
+            }
+        }
+    }
+    if (modified) {
+        tree.overwrite(workspaceFileName, JSON.stringify(workspace, null, '\t'));
+    }
+}
+/**
+ * Step 3: Migrate federation.config.js files from CJS to ESM
+ * - require() → import
+ * - module.exports = → export default
+ * - Update package references from v3 to v4
+ */
+function migrateFederationConfigs(tree, workspace, options) {
+    const projects = resolveProjects(workspace, options);
+    for (const { projectRoot } of projects) {
+        const configPath = path.join(projectRoot, 'federation.config.js');
+        if (!tree.exists(configPath)) {
+            continue;
+        }
+        let content = tree.readText(configPath);
+        const originalContent = content;
+        // Convert CJS require to ESM import
+        // Matches: const { foo, bar } = require('...');
+        const requireRegex = /const\s+(\{[^}]+\})\s*=\s*require\(\s*['"]([^'"]+)['"]\s*\)\s*;?/g;
+        const imports = [];
+        content = content.replace(requireRegex, (_match, bindings, modulePath) => {
+            const updatedPath = modulePath.replace(V3_PACKAGE, V4_PACKAGE);
+            imports.push(`import ${bindings} from '${updatedPath}';`);
+            return ''; // Remove the require line; import will be prepended
+        });
+        // Prepend collected imports at the top (after removing old requires)
+        if (imports.length > 0) {
+            content = imports.join('\n') + '\n' + content.trimStart();
+        }
+        // Convert module.exports = to export default
+        content = content.replace(/module\.exports\s*=\s*/, 'export default ');
+        // Also update any remaining inline @angular-architects/native-federation references
+        // (e.g. in comments or other import paths) to the v4 package
+        content = content.replace(new RegExp(escapeRegExp(V3_PACKAGE + '/config'), 'g'), V4_PACKAGE + '/config');
+        content = content.replace(new RegExp(escapeRegExp(V3_PACKAGE) + '(?!/)', 'g'), V4_PACKAGE);
+        if (content !== originalContent) {
+            tree.overwrite(configPath, content);
+            console.log(`Migrated ${configPath} to ESM`);
+        }
+    }
+}
+/**
+ * Step 4: Update main.ts imports from @angular-architects/native-federation
+ * to @softarc/native-federation-runtime
+ */
+function migrateMainTs(tree, workspace, options) {
+    const projects = resolveProjects(workspace, options);
+    for (const { projectConfig } of projects) {
+        const main = projectConfig?.architect?.build?.options?.browser ??
+            projectConfig?.architect?.build?.options?.main ??
+            projectConfig?.architect?.esbuild?.options?.browser ??
+            projectConfig?.architect?.esbuild?.options?.main;
+        if (!main || !tree.exists(main)) {
+            continue;
+        }
+        let content = tree.readText(main);
+        const originalContent = content;
+        // Update initFederation import
+        content = content.replace(new RegExp(escapeRegExp(V3_RUNTIME_IMPORT), 'g'), V4_RUNTIME_IMPORT);
+        if (content !== originalContent) {
+            tree.overwrite(main, content);
+            console.log(`Updated initFederation import in ${main}`);
+        }
+    }
+}
+/**
+ * Optional Step 5: Add @softarc/native-federation-orchestrator to package.json dependencies
+ */
+function installOrchestratorPackage(tree) {
+    const packageJson = JSON.parse(tree.read('package.json')?.toString('utf8') ?? '{}');
+    if (!packageJson.dependencies) {
+        packageJson.dependencies = {};
+    }
+    if (!packageJson.dependencies[ORCHESTRATOR_PACKAGE]) {
+        packageJson.dependencies[ORCHESTRATOR_PACKAGE] = '^4.0.0-RC4';
+        tree.overwrite('package.json', JSON.stringify(packageJson, null, 2));
+        console.log(`Added ${ORCHESTRATOR_PACKAGE} to dependencies`);
+    }
+}
+/**
+ * Optional Step 6: Surgically update main.ts to use the orchestrator.
+ *
+ * - Replaces the initFederation import source with @softarc/native-federation-orchestrator
+ * - Adds the orchestrator /options import
+ * - Rewrites the initFederation() call:
+ *   - If it had a first argument, keeps it and appends the orchestrator options as second arg
+ *   - If it had no arguments, uses {} as first arg and the orchestrator options as second arg
+ */
+function migrateMainTsToOrchestrator(tree, workspace, options) {
+    const projects = resolveProjects(workspace, options);
+    const orchestratorOptions = `{
+  ...useShimImportMap({ shimMode: true }),
+  logger: consoleLogger,
+  storage: globalThisStorageEntry,
+  hostRemoteEntry: './remoteEntry.json',
+  logLevel: 'debug',
+}`;
+    const optionsImport = `import {
+  useShimImportMap,
+  consoleLogger,
+  globalThisStorageEntry,
+} from '${ORCHESTRATOR_PACKAGE}/options';`;
+    for (const { projectConfig } of projects) {
+        const main = projectConfig?.architect?.build?.options?.browser ??
+            projectConfig?.architect?.build?.options?.main ??
+            projectConfig?.architect?.esbuild?.options?.browser ??
+            projectConfig?.architect?.esbuild?.options?.main;
+        if (!main || !tree.exists(main)) {
+            continue;
+        }
+        let content = tree.readText(main);
+        // 1. Replace the import source to the orchestrator package
+        content = content.replace(new RegExp(`from\\s+['"](?:${escapeRegExp(V4_RUNTIME_IMPORT)}|${escapeRegExp(V3_RUNTIME_IMPORT)})['"]`, 'g'), `from '${ORCHESTRATOR_PACKAGE}'`);
+        // 2. Add the /options import after the orchestrator import line
+        if (!content.includes(`${ORCHESTRATOR_PACKAGE}/options`)) {
+            content = content.replace(new RegExp(`(import\\s+\\{[^}]*\\}\\s+from\\s+['"]${escapeRegExp(ORCHESTRATOR_PACKAGE)}['"];?)`), `$1\n${optionsImport}`);
+        }
+        // 3. Rewrite initFederation(...) call — extract existing first arg if present
+        const initMatch = content.match(/initFederation\s*\(([^)]*)\)/s);
+        if (initMatch) {
+            const existingArgs = initMatch[1].trim();
+            const firstArg = existingArgs.length > 0 ? existingArgs : '{}';
+            content = content.replace(initMatch[0], `initFederation(${firstArg}, ${orchestratorOptions})`);
+        }
+        tree.overwrite(main, content);
+        console.log(`Switched ${main} to use the orchestrator`);
+    }
+}
+function resolveProjects(workspace, options) {
+    const projects = [];
+    if (options.project) {
+        const projectConfig = workspace.projects?.[options.project];
+        if (projectConfig) {
+            projects.push({
+                projectName: options.project,
+                projectRoot: projectConfig.root?.replace(/\\/g, '/') ?? '',
+                projectConfig,
+            });
+        }
+    }
+    else {
+        // Migrate all projects
+        for (const projectName of Object.keys(workspace.projects ?? {})) {
+            const projectConfig = workspace.projects[projectName];
+            projects.push({
+                projectName,
+                projectRoot: projectConfig.root?.replace(/\\/g, '/') ?? '',
+                projectConfig,
+            });
+        }
+    }
+    return projects;
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/utils/angular-bundler.d.ts

@@ -1,12 +1,7 @@
 import * as esbuild from 'esbuild';
-import { type SourceFileCache } from '@angular/build/private';
-import type { BuilderContext } from '@angular-devkit/architect';
-import type { ApplicationBuilderOptions } from '@angular/build';
-import type { EntryPoint, FederationCache } from '@softarc/native-federation';
-import type { MappedPath } from '@softarc/native-federation/internal';
-export interface AngularBundleResult {
+import type { NormalizedContextOptions } from './normalize-context-options.js';
+export declare function createAngularEsbuildContext(options: NormalizedContextOptions): Promise<{
     ctx: esbuild.BuildContext;
     pluginDisposed: Promise<void>;
-}
-export declare function createAngularEsbuildContext(builderOptions: ApplicationBuilderOptions, context: BuilderContext, entryPoints: EntryPoint[], external: string[], outdir: string, tsConfigPath: string, mappedPaths: MappedPath[], cache: FederationCache<SourceFileCache>, dev?: boolean, hash?: boolean, chunks?: boolean, platform?: 'browser' | 'node', optimizedMappings?: boolean): Promise<AngularBundleResult>;
+}>;
 //# sourceMappingURL=angular-bundler.d.ts.map

package/src/utils/angular-bundler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angular-bundler.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-bundler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAOnC,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAOhE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAKtE,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,wBAAsB,2BAA2B,CAC/C,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,UAAU,EAAE,EACzB,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,UAAU,EAAE,EACzB,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,EACvC,GAAG,CAAC,EAAE,OAAO,EACb,IAAI,GAAE,OAAe,EACrB,MAAM,CAAC,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,SAAS,GAAG,MAAM,EAC7B,iBAAiB,CAAC,EAAE,OAAO,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CAkI9B"}
+{"version":3,"file":"angular-bundler.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-bundler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAoBnC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAG/E,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC;IAC5F,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC,CAkJD"}

package/src/utils/angular-bundler.js

@@ -1,14 +1,16 @@
 import * as esbuild from 'esbuild';
 import * as path from 'path';
-import * as fs from 'fs';
 import { createRequire } from 'node:module';
-import { isDeepStrictEqual } from 'node:util';
-import JSON5 from 'json5';
 import { transformSupportedBrowsersToTargets, getSupportedBrowsers, generateSearchDirectories, findTailwindConfiguration, loadPostcssConfiguration, } from '@angular/build/private';
 import { normalizeOptimization, normalizeSourceMaps, } from '@angular-devkit/build-angular/src/utils/index.js';
-import { createSharedMappingsPlugin } from './shared-mappings-plugin.js';
 import { createAwaitableCompilerPlugin } from './create-awaitable-compiler-plugin.js';
-export async function createAngularEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache, dev, hash = false, chunks, platform, optimizedMappings) {
+import { createFederationTsConfig } from './create-federation-tsconfig.js';
+export async function createAngularEsbuildContext(options) {
+    const { builderOptions, context, entryPoints, external, outdir, cache, dev, hash, chunks, platform, optimizedMappings, } = options;
+    let tsConfigPath = options.tsConfigPath;
+    if (!tsConfigPath) {
+        throw new Error('tsConfigPath is required for Angular/esbuild context creation');
+    }
     const workspaceRoot = context.workspaceRoot;
     const projectMetadata = await context.getProjectMetadata(context.target.project);
     const projectRoot = path.join(workspaceRoot, projectMetadata['root'] ?? '');
@@ -32,7 +34,7 @@ export async function createAngularEsbuildContext(builderOptions, context, entry
             fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(workspaceRoot, replacement.with);
         }
     }
-    tsConfigPath = createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints, optimizedMappings);
+    tsConfigPath = createFederationTsConfig(workspaceRoot, tsConfigPath, entryPoints, optimizedMappings);
     const pluginOptions = {
         sourcemap: !!sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
         thirdPartySourcemaps: sourcemapOptions.vendor,
@@ -95,13 +97,9 @@ export async function createAngularEsbuildContext(builderOptions, context, entry
         format: 'esm',
         target: target,
         logLimit: 0,
-        plugins: [
-            compilerPlugin,
-            ...(mappedPaths && mappedPaths.length > 0 ? [createSharedMappingsPlugin(mappedPaths)] : []),
-            commonjsPlugin(),
-        ],
+        plugins: [compilerPlugin, commonjsPlugin()],
         define: {
-            ...(!dev ? { ngDevMode: 'false' } : {}),
+            ngDevMode: dev ? 'true' : 'false',
             ngJitMode: 'false',
         },
         ...(builderOptions.loader ? { loader: builderOptions.loader } : {}),
@@ -120,48 +118,3 @@ async function getTailwindConfig(searchDirectories) {
         package: createRequire(tailwindConfigurationPath).resolve('tailwindcss'),
     };
 }
-/**
- * Creates a tsconfig.federation.json that includes the federation entry points.
- */
-function createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints, optimizedMappings) {
-    const fullTsConfigPath = path.join(workspaceRoot, tsConfigPath);
-    const tsconfigDir = path.dirname(fullTsConfigPath);
-    const tsconfigAsString = fs.readFileSync(fullTsConfigPath, 'utf-8');
-    const tsconfig = JSON5.parse(tsconfigAsString);
-    tsconfig.files = entryPoints
-        .filter(ep => ep.fileName.startsWith('.'))
-        .map(ep => path.relative(tsconfigDir, ep.fileName).replace(/\\\\/g, '/'));
-    if (optimizedMappings) {
-        const filtered = entryPoints
-            .filter(ep => !ep.fileName.startsWith('.'))
-            .map(ep => path.relative(tsconfigDir, ep.fileName).replace(/\\\\/g, '/'));
-        if (!tsconfig.include) {
-            tsconfig.include = [];
-        }
-        for (const ep of filtered) {
-            if (!tsconfig.include.includes(ep)) {
-                tsconfig.include.push(ep);
-            }
-        }
-    }
-    const content = JSON5.stringify(tsconfig, null, 2);
-    const tsconfigFedPath = path.join(tsconfigDir, 'tsconfig.federation.json');
-    if (!doesFileExistAndJsonEqual(tsconfigFedPath, content)) {
-        fs.writeFileSync(tsconfigFedPath, JSON.stringify(tsconfig, null, 2));
-    }
-    return tsconfigFedPath;
-}
-function doesFileExistAndJsonEqual(filePath, content) {
-    if (!fs.existsSync(filePath)) {
-        return false;
-    }
-    try {
-        const currentContent = fs.readFileSync(filePath, 'utf-8');
-        const currentJson = JSON5.parse(currentContent);
-        const newJson = JSON5.parse(content);
-        return isDeepStrictEqual(currentJson, newJson);
-    }
-    catch {
-        return false;
-    }
-}

package/src/utils/angular-esbuild-adapter.d.ts

@@ -1,10 +1,11 @@
-import { type NFBuildAdapter } from '@softarc/native-federation';
+import { type NFBuildAdapter, type NFBuildAdapterContext, type FederationCache } from '@softarc/native-federation';
 import * as esbuild from 'esbuild';
+import type { SourceFileCache } from '@angular/build/private';
 import type { BuilderContext } from '@angular-devkit/architect';
 import type { ApplicationBuilderOptions } from '@angular/build';
-export interface EsbuildContextResult {
-    ctx: esbuild.BuildContext;
+export interface EsbuildContextResult extends NFBuildAdapterContext<esbuild.BuildContext> {
     pluginDisposed: Promise<void>;
+    cache: FederationCache<SourceFileCache>;
 }
-export declare function createAngularBuildAdapter(builderOptions: ApplicationBuilderOptions, context: BuilderContext): NFBuildAdapter;
+export declare function createAngularBuildAdapter(ngBuilderOptions: ApplicationBuilderOptions, context: BuilderContext): NFBuildAdapter;
 //# sourceMappingURL=angular-esbuild-adapter.d.ts.map

package/src/utils/angular-esbuild-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angular-esbuild-adapter.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-esbuild-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,cAAc,EAKpB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAEnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAKhE,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AA+FD,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,GACtB,cAAc,CAqHhB"}
+{"version":3,"file":"angular-esbuild-adapter.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-esbuild-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACrB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAKhE,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB,CAAC,OAAO,CAAC,YAAY,CAAC;IACvF,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;CACzC;AAsCD,wBAAgB,yBAAyB,CACvC,gBAAgB,EAAE,yBAAyB,EAC3C,OAAO,EAAE,cAAc,GACtB,cAAc,CA8FhB"}

package/src/utils/angular-esbuild-adapter.js

@@ -4,12 +4,7 @@ import { AbortedError } from '@softarc/native-federation/internal';
 import * as esbuild from 'esbuild';
 import { createAngularEsbuildContext } from './angular-bundler.js';
 import { createNodeModulesEsbuildContext } from './node-modules-bundler.js';
-async function createEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache, dev, isNodeModules, hash = false, chunks, platform, optimizedMappings) {
-    if (isNodeModules) {
-        return createNodeModulesEsbuildContext(builderOptions, context, entryPoints, external, outdir, mappedPaths, cache, dev, hash, chunks, platform);
-    }
-    return createAngularEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache, dev, hash, chunks, platform, optimizedMappings);
-}
+import { normalizeContextOptions } from './normalize-context-options.js';
 function writeResult(result, outdir) {
     const writtenFiles = [];
     for (const outFile of result.outputFiles ?? []) {
@@ -42,7 +37,7 @@ function setNgServerMode() {
         console.error('Error patching file ', fileToPatch, '\nIs it write-protected?');
     }
 }
-export function createAngularBuildAdapter(builderOptions, context) {
+export function createAngularBuildAdapter(ngBuilderOptions, context) {
     const bundleContextCache = new Map();
     const dispose = async (name) => {
         if (name) {
@@ -65,21 +60,23 @@ export function createAngularBuildAdapter(builderOptions, context) {
         await Promise.all(disposals);
         await esbuild.stop();
     };
-    const setup = async (options) => {
-        const { entryPoints, tsConfigPath, external, outdir, mappedPaths, bundleName, isNodeModules, dev, chunks, hash, platform, optimizedMappings, cache, } = options;
+    const setup = async (name, adapterOptions) => {
         setNgServerMode();
-        if (bundleContextCache.has(bundleName)) {
+        if (bundleContextCache.has(name)) {
             return;
         }
-        const { ctx, pluginDisposed } = await createEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache, dev, isNodeModules, hash, chunks, platform, optimizedMappings);
-        bundleContextCache.set(bundleName, {
+        const normalizedOptions = normalizeContextOptions(ngBuilderOptions, context, adapterOptions);
+        const { ctx, pluginDisposed } = normalizedOptions.isMappingOrExposed
+            ? await createAngularEsbuildContext(normalizedOptions)
+            : await createNodeModulesEsbuildContext(normalizedOptions);
+        bundleContextCache.set(name, {
             ctx,
             pluginDisposed,
-            outdir,
-            cache,
-            isNodeModules,
-            dev: !!dev,
-            name: bundleName,
+            outdir: normalizedOptions.outdir,
+            cache: normalizedOptions.cache,
+            isMappingOrExposed: normalizedOptions.isMappingOrExposed,
+            dev: normalizedOptions.dev,
+            name,
         });
     };
     const build = async (name, opts = {}) => {
@@ -91,8 +88,8 @@ export function createAngularBuildAdapter(builderOptions, context) {
             throw new AbortedError('[build] Aborted before rebuild');
         }
         try {
-            if (opts.files) {
-                bundleContext.cache.bundlerCache.invalidate(new Set(opts.files));
+            if (opts.modifiedFiles) {
+                bundleContext.cache.bundlerCache.invalidate(new Set(opts.modifiedFiles));
             }
             const result = await bundleContext.ctx.rebuild();
             const writtenFiles = writeResult(result, bundleContext.outdir);

package/src/utils/angular-locales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"angular-locales.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-locales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAE/E,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,qEAuBzD"}
+{"version":3,"file":"angular-locales.d.ts","sourceRoot":"","sources":["../../../src/utils/angular-locales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAE/E,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,GAAE;IAAE,MAAM,CAAC,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,qEA0BzD"}

package/src/utils/create-federation-tsconfig.d.ts

@@ -0,0 +1,6 @@
+import type { EntryPoint } from '@softarc/native-federation';
+/**
+ * Creates a tsconfig.federation.json that includes the federation entry points.
+ */
+export declare function createFederationTsConfig(workspaceRoot: string, tsConfigPath: string, entryPoints: EntryPoint[], optimizedMappings?: boolean): string;
+//# sourceMappingURL=create-federation-tsconfig.d.ts.map

package/src/utils/create-federation-tsconfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-federation-tsconfig.d.ts","sourceRoot":"","sources":["../../../src/utils/create-federation-tsconfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM7D;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,UAAU,EAAE,EACzB,iBAAiB,CAAC,EAAE,OAAO,GAC1B,MAAM,CAoCR"}