@angular-architects/native-federation-v4 21.1.6 → 21.1.8

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

@@ -1,74 +1,98 @@
-import { logger, AbortedError } from '@softarc/native-federation/internal';
-import * as esbuild from 'esbuild';
-import { transformSupportedBrowsersToTargets, getSupportedBrowsers, generateSearchDirectories, findTailwindConfiguration, loadPostcssConfiguration, } from '@angular/build/private';
-import { createCompilerPluginOptions } from './create-compiler-options.js';
-import { normalizeOptimization, normalizeSourceMaps, } from '@angular-devkit/build-angular/src/utils/index.js';
-import { createRequire } from 'node:module';
 import * as fs from 'fs';
 import * as path from 'path';
-import { createSharedMappingsPlugin } from './shared-mappings-plugin.js';
-import { transformAsync } from '@babel/core';
-import JSON5 from 'json5';
-import { isDeepStrictEqual } from 'node:util';
-import { createAwaitableCompilerPlugin } from './create-awaitable-compiler-plugin.js';
-export function createAngularBuildAdapter(builderOptions, context) {
-    const contextCache = new Map();
+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';
+import { normalizeContextOptions } from './normalize-context-options.js';
+function writeResult(result, outdir) {
+    const writtenFiles = [];
+    for (const outFile of result.outputFiles ?? []) {
+        const fileName = path.basename(outFile.path);
+        const filePath = path.join(outdir, fileName);
+        fs.writeFileSync(filePath, outFile.text);
+        writtenFiles.push(filePath);
+    }
+    return writtenFiles;
+}
+/**
+ * Patches @angular/core to infer ngServerMode at runtime.
+ * Usually, ngServerMode is set during bundling. However, we need to infer this
+ * value at runtime as we are using the same shared bundle for @angular/core
+ * on the server and in the browser.
+ */
+function setNgServerMode() {
+    const fileToPatch = 'node_modules/@angular/core/fesm2022/core.mjs';
+    const lineToAdd = `if (typeof globalThis.ngServerMode ==='undefined') globalThis.ngServerMode = (typeof window === 'undefined') ? true : false;`;
+    try {
+        if (fs.existsSync(fileToPatch)) {
+            let content = fs.readFileSync(fileToPatch, 'utf-8');
+            if (!content.includes(lineToAdd)) {
+                content = lineToAdd + '\n' + content;
+                fs.writeFileSync(fileToPatch, content);
+            }
+        }
+    }
+    catch {
+        console.error('Error patching file ', fileToPatch, '\nIs it write-protected?');
+    }
+}
+export function createAngularBuildAdapter(ngBuilderOptions, context) {
+    const bundleContextCache = new Map();
     const dispose = async (name) => {
         if (name) {
-            if (!contextCache.has(name))
+            if (!bundleContextCache.has(name))
                 throw new Error(`Could not dispose of non-existing build '${name}'`);
-            const entry = contextCache.get(name);
+            const entry = bundleContextCache.get(name);
             await entry.ctx.dispose();
             await entry.pluginDisposed;
-            contextCache.delete(name);
+            bundleContextCache.delete(name);
             return;
         }
-        // Dispose all if no specific build provided
         const disposals = [];
-        for (const [, entry] of contextCache) {
+        for (const [, entry] of bundleContextCache) {
             disposals.push((async () => {
                 await entry.ctx.dispose();
                 await entry.pluginDisposed;
             })());
         }
-        contextCache.clear();
+        bundleContextCache.clear();
         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 (contextCache.has(bundleName)) {
+        if (bundleContextCache.has(name)) {
             return;
         }
-        const { ctx, pluginDisposed } = await createEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache.bundlerCache, dev, isNodeModules, hash, chunks, platform, optimizedMappings);
-        contextCache.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,
-            isNodeModules,
-            dev: !!dev,
-            name: bundleName,
-            entryPoints,
-            workspaceRoot: context.workspaceRoot,
+            outdir: normalizedOptions.outdir,
+            cache: normalizedOptions.cache,
+            isMappingOrExposed: normalizedOptions.isMappingOrExposed,
+            dev: normalizedOptions.dev,
+            name,
         });
     };
     const build = async (name, opts = {}) => {
-        const cached = contextCache.get(name);
-        if (!cached) {
+        const bundleContext = bundleContextCache.get(name);
+        if (!bundleContext) {
             throw new Error(`No context found for build "${name}". Call setup() first.`);
         }
         if (opts?.signal?.aborted) {
             throw new AbortedError('[build] Aborted before rebuild');
         }
         try {
-            const result = await cached.ctx.rebuild();
-            const writtenFiles = writeResult(result, cached.outdir);
-            if (cached.isNodeModules) {
-                const scriptFiles = writtenFiles.filter(f => f.endsWith('.js') || f.endsWith('.mjs'));
-                for (const file of scriptFiles) {
-                    await link(file, cached.dev);
-                }
+            if (opts.files) {
+                bundleContext.cache.bundlerCache.invalidate(new Set(opts.files));
             }
+            const result = await bundleContext.ctx.rebuild();
+            const writtenFiles = writeResult(result, bundleContext.outdir);
             return writtenFiles.map(fileName => ({ fileName }));
         }
         catch (error) {
@@ -80,209 +104,3 @@ export function createAngularBuildAdapter(builderOptions, context) {
     };
     return { setup, build, dispose };
 }
-async function link(outfile, dev) {
-    const code = fs.readFileSync(outfile, 'utf-8');
-    try {
-        const linkerEsm = await loadEsmModule('@angular/compiler-cli/linker/babel');
-        const linker = linkerEsm.default;
-        const result = await transformAsync(code, {
-            filename: outfile,
-            compact: !dev,
-            configFile: false,
-            babelrc: false,
-            minified: !dev,
-            browserslistConfigFile: false,
-            plugins: [linker],
-        });
-        if (!result)
-            logger.warn(`File ${outfile} could not be linked.`);
-        if (!result?.code) {
-            logger.warn(`File ${outfile} seems to be empty.`);
-            return;
-        }
-        fs.writeFileSync(outfile, result.code, 'utf-8');
-    }
-    catch (e) {
-        logger.error('error linking');
-        if (fs.existsSync(`${outfile}.error`)) {
-            fs.unlinkSync(`${outfile}.error`);
-        }
-        fs.renameSync(outfile, `${outfile}.error`);
-        throw e;
-    }
-}
-async function createEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, sourceFileCache, dev, isNodeModules, hash = false, chunks, platform, optimizedMappings) {
-    const workspaceRoot = context.workspaceRoot;
-    const projectMetadata = await context.getProjectMetadata(context.target.project);
-    const projectRoot = path.join(workspaceRoot, projectMetadata['root'] ?? '');
-    const browsers = getSupportedBrowsers(projectRoot, context.logger);
-    const target = transformSupportedBrowsersToTargets(browsers);
-    const optimizationOptions = normalizeOptimization(builderOptions.optimization);
-    const sourcemapOptions = normalizeSourceMaps(builderOptions.sourceMap);
-    const searchDirectories = await generateSearchDirectories([projectRoot, workspaceRoot]);
-    const postcssConfiguration = await loadPostcssConfiguration(searchDirectories);
-    const tailwindConfiguration = postcssConfiguration
-        ? undefined
-        : await getTailwindConfig(searchDirectories);
-    const outputNames = {
-        bundles: '[name]',
-        media: 'media/[name]',
-    };
-    let fileReplacements;
-    if (builderOptions.fileReplacements) {
-        for (const replacement of builderOptions.fileReplacements) {
-            fileReplacements ??= {};
-            fileReplacements[path.join(workspaceRoot, replacement.replace)] = path.join(workspaceRoot, replacement.with);
-        }
-    }
-    if (!optimizedMappings) {
-        tsConfigPath = createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints);
-    }
-    const pluginOptions = createCompilerPluginOptions({
-        workspaceRoot,
-        optimizationOptions,
-        sourcemapOptions,
-        tsconfig: tsConfigPath,
-        outputNames,
-        fileReplacements,
-        externalDependencies: external,
-        preserveSymlinks: builderOptions.preserveSymlinks,
-        stylePreprocessorOptions: builderOptions.stylePreprocessorOptions,
-        advancedOptimizations: !dev,
-        inlineStyleLanguage: builderOptions.inlineStyleLanguage,
-        jit: false,
-        tailwindConfiguration,
-        postcssConfiguration,
-        incremental: !isNodeModules,
-    }, target, sourceFileCache);
-    const commonjsPluginModule = await import('@chialab/esbuild-plugin-commonjs');
-    const commonjsPlugin = commonjsPluginModule.default;
-    pluginOptions.styleOptions.externalDependencies = [];
-    const [compilerPlugin, pluginDisposed] = createAwaitableCompilerPlugin(pluginOptions.pluginOptions, pluginOptions.styleOptions);
-    const config = {
-        entryPoints: entryPoints.map(ep => ({
-            in: ep.fileName,
-            out: path.parse(ep.outName).name,
-        })),
-        outdir,
-        entryNames: hash ? '[name]-[hash]' : '[name]',
-        write: false,
-        external,
-        logLevel: 'warning',
-        bundle: true,
-        sourcemap: sourcemapOptions.scripts,
-        minify: !dev,
-        supported: {
-            'async-await': false,
-            'object-rest-spread': false,
-        },
-        splitting: chunks,
-        platform: platform ?? 'browser',
-        format: 'esm',
-        target: target,
-        logLimit: isNodeModules ? 1 : 0,
-        plugins: [
-            compilerPlugin,
-            ...(mappedPaths && mappedPaths.length > 0 ? [createSharedMappingsPlugin(mappedPaths)] : []),
-            commonjsPlugin(),
-        ],
-        define: {
-            ...(!dev ? { ngDevMode: 'false' } : {}),
-            ngJitMode: 'false',
-        },
-        ...(builderOptions.loader ? { loader: builderOptions.loader } : {}),
-        resolveExtensions: ['.ts', '.tsx', '.mjs', '.js', '.cjs'],
-    };
-    const ctx = await esbuild.context(config);
-    return { ctx, pluginDisposed };
-}
-async function getTailwindConfig(searchDirectories) {
-    const tailwindConfigurationPath = findTailwindConfiguration(searchDirectories);
-    if (!tailwindConfigurationPath) {
-        return undefined;
-    }
-    return {
-        file: tailwindConfigurationPath,
-        package: createRequire(tailwindConfigurationPath).resolve('tailwindcss'),
-    };
-}
-function createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints) {
-    const fullTsConfigPath = path.join(workspaceRoot, tsConfigPath);
-    const tsconfigDir = path.dirname(fullTsConfigPath);
-    const filtered = entryPoints
-        .filter(ep => !ep.fileName.includes('/node_modules/') && !ep.fileName.startsWith('.'))
-        .map(ep => path.relative(tsconfigDir, ep.fileName).replace(/\\\\/g, '/'));
-    const tsconfigAsString = fs.readFileSync(fullTsConfigPath, 'utf-8');
-    const tsconfig = JSON5.parse(tsconfigAsString);
-    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));
-    }
-    tsConfigPath = tsconfigFedPath;
-    return tsConfigPath;
-}
-/**
- * Checks if a file exists and if its content is equal to the provided content.
- * If the file does not exist, it returns false.
- * If the file or its content is invalid JSON, it returns false.
- * @param {string} path - The path to the file
- * @param {string} content - The content to compare with
- * @returns {boolean} - Returns true if the file exists and its content is equal to the provided content
- */
-function doesFileExistAndJsonEqual(path, content) {
-    if (!fs.existsSync(path)) {
-        return false;
-    }
-    try {
-        const currentContent = fs.readFileSync(path, 'utf-8');
-        const currentJson = JSON5.parse(currentContent);
-        const newJson = JSON5.parse(content);
-        return isDeepStrictEqual(currentJson, newJson);
-    }
-    catch {
-        return false;
-    }
-}
-function writeResult(result, outdir) {
-    const writtenFiles = [];
-    for (const outFile of result.outputFiles ?? []) {
-        const fileName = path.basename(outFile.path);
-        const filePath = path.join(outdir, fileName);
-        fs.writeFileSync(filePath, outFile.text);
-        writtenFiles.push(filePath);
-    }
-    return writtenFiles;
-}
-export function loadEsmModule(modulePath) {
-    return new Function('modulePath', `return import(modulePath);`)(modulePath);
-}
-//
-//  Usually, ngServerMode is set during bundling. However, we need to infer this
-//  value at runtime as we are using the same shared bundle for @angular/core
-//  on the server and in the browser.
-//
-function setNgServerMode() {
-    const fileToPatch = 'node_modules/@angular/core/fesm2022/core.mjs';
-    const lineToAdd = `if (typeof globalThis.ngServerMode ==='undefined') globalThis.ngServerMode = (typeof window === 'undefined') ? true : false;`;
-    try {
-        if (fs.existsSync(fileToPatch)) {
-            let content = fs.readFileSync(fileToPatch, 'utf-8');
-            if (!content.includes(lineToAdd)) {
-                content = lineToAdd + '\n' + content;
-                fs.writeFileSync(fileToPatch, content);
-            }
-        }
-    }
-    catch {
-        console.error('Error patching file ', fileToPatch, '\nIs it write-protected?');
-    }
-}

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"}

package/src/utils/create-federation-tsconfig.js

@@ -0,0 +1,49 @@
+import path from 'path';
+import fs from 'fs';
+import JSON5 from 'json5';
+import { isDeepStrictEqual } from 'util';
+/**
+ * Creates a tsconfig.federation.json that includes the federation entry points.
+ */
+export function createFederationTsConfig(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/get-fallback-platform.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_SERVER_DEPS_LIST: string[];
+export declare function getDefaultPlatform(cur: string): 'browser' | 'node';
+//# sourceMappingURL=get-fallback-platform.d.ts.map

package/src/utils/get-fallback-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-fallback-platform.d.ts","sourceRoot":"","sources":["../../../src/utils/get-fallback-platform.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,EAAE,MAAM,EAI5C,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAMlE"}

package/src/utils/get-fallback-platform.js

@@ -0,0 +1,13 @@
+export const DEFAULT_SERVER_DEPS_LIST = [
+    '@angular/platform-server',
+    '@angular/platform-server/init',
+    '@angular/ssr',
+];
+export function getDefaultPlatform(cur) {
+    if (DEFAULT_SERVER_DEPS_LIST.find(e => cur.startsWith(e))) {
+        return 'node';
+    }
+    else {
+        return 'browser';
+    }
+}

package/src/utils/node-modules-bundler.d.ts

@@ -0,0 +1,7 @@
+import * as esbuild from 'esbuild';
+import type { NormalizedContextOptions } from './normalize-context-options.js';
+export declare function createNodeModulesEsbuildContext(options: NormalizedContextOptions): Promise<{
+    ctx: esbuild.BuildContext;
+    pluginDisposed: Promise<void>;
+}>;
+//# sourceMappingURL=node-modules-bundler.d.ts.map

package/src/utils/node-modules-bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-modules-bundler.d.ts","sourceRoot":"","sources":["../../../src/utils/node-modules-bundler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAanC,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAiE/E,wBAAsB,+BAA+B,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC;IAChG,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC,CAqFD"}

package/src/utils/node-modules-bundler.js

@@ -0,0 +1,109 @@
+import * as esbuild from 'esbuild';
+import * as path from 'path';
+import * as fs from 'fs';
+import { transformSupportedBrowsersToTargets, getSupportedBrowsers, JavaScriptTransformer, Cache, } from '@angular/build/private';
+import { normalizeSourceMaps } from '@angular-devkit/build-angular/src/utils/index.js';
+const LINKER_DECLARATION_PREFIX = 'ɵɵngDeclare';
+/**
+ * Excludes @angular/core and @angular/compiler which define the declarations
+ * and would cause false positives.
+ */
+function requiresLinking(filePath, source) {
+    if (/[\\/]@angular[\\/](?:compiler|core)[\\/]/.test(filePath)) {
+        return false;
+    }
+    return source.includes(LINKER_DECLARATION_PREFIX);
+}
+/**
+ * Creates an esbuild plugin that applies the Angular linker to partially compiled
+ * Angular libraries like a design system.
+ *
+ * Uses Angular's JavaScriptTransformer which handles linking internally.
+ */
+function createAngularLinkerPlugin(jsTransformer, advancedOptimizations) {
+    return {
+        name: 'angular-linker',
+        setup(build) {
+            build.onLoad({ filter: /\.m?js$/ }, async (args) => {
+                const contents = await fs.promises.readFile(args.path, 'utf-8');
+                const needsLinking = requiresLinking(args.path, contents);
+                if (!needsLinking && !advancedOptimizations) {
+                    return null;
+                }
+                const result = await jsTransformer.transformData(args.path, contents, !needsLinking, undefined);
+                return {
+                    contents: Buffer.from(result).toString('utf-8'),
+                    loader: 'js',
+                };
+            });
+        },
+    };
+}
+const jsTransformerCacheStores = new Map();
+function getOrCreateJsTransformerCacheStore(cachePath) {
+    let store = jsTransformerCacheStores.get(cachePath);
+    if (!store) {
+        store = new Map();
+        jsTransformerCacheStores.set(cachePath, store);
+    }
+    return store;
+}
+export async function createNodeModulesEsbuildContext(options) {
+    const { builderOptions, context, entryPoints, external, outdir, cache, dev, hash, chunks, platform, } = options;
+    const workspaceRoot = context.workspaceRoot;
+    const projectMetadata = await context.getProjectMetadata(context.target.project);
+    const projectRoot = path.join(workspaceRoot, projectMetadata['root'] ?? '');
+    const browsers = getSupportedBrowsers(projectRoot, context.logger);
+    const target = transformSupportedBrowsersToTargets(browsers);
+    const sourcemapOptions = normalizeSourceMaps(builderOptions.sourceMap);
+    const commonjsPluginModule = await import('@chialab/esbuild-plugin-commonjs');
+    const commonjsPlugin = commonjsPluginModule.default;
+    // Create JavaScriptTransformer for handling Angular partial compilation linking
+    const advancedOptimizations = !dev;
+    const jsTransformerCacheStore = getOrCreateJsTransformerCacheStore(cache.cachePath);
+    const jsTransformerCache = new Cache(jsTransformerCacheStore, 'jstransformer');
+    const jsTransformer = new JavaScriptTransformer({
+        sourcemap: !!sourcemapOptions.scripts,
+        thirdPartySourcemaps: false,
+        advancedOptimizations,
+        jit: false,
+    }, 1, // maxThreads - keep low for node_modules bundling
+    jsTransformerCache);
+    const config = {
+        entryPoints: entryPoints.map(ep => ({
+            in: ep.fileName,
+            out: path.parse(ep.outName).name,
+        })),
+        outdir,
+        entryNames: hash ? '[name]-[hash]' : '[name]',
+        write: false,
+        external,
+        logLevel: 'warning',
+        bundle: true,
+        sourcemap: sourcemapOptions.scripts,
+        minify: !dev,
+        supported: {
+            'async-await': false,
+            'object-rest-spread': false,
+        },
+        splitting: chunks,
+        platform: platform ?? 'browser',
+        format: 'esm',
+        target: target,
+        logLimit: 1,
+        plugins: [createAngularLinkerPlugin(jsTransformer, advancedOptimizations), commonjsPlugin()],
+        define: {
+            ngDevMode: dev ? 'true' : 'false',
+            ngJitMode: 'false',
+        },
+        ...(builderOptions.loader ? { loader: builderOptions.loader } : {}),
+        resolveExtensions: ['.mjs', '.js', '.cjs'],
+    };
+    const ctx = await esbuild.context(config);
+    const originalDispose = ctx.dispose.bind(ctx);
+    ctx.dispose = async () => {
+        await originalDispose();
+        await jsTransformer.close();
+    };
+    return { ctx, pluginDisposed: Promise.resolve() };
+}

package/src/utils/normalize-context-options.d.ts

@@ -0,0 +1,23 @@
+import type { ApplicationBuilderOptions } from '@angular/build';
+import type { BuilderContext } from '@angular-devkit/architect';
+import type { SourceFileCache } from '@angular/build/private';
+import type { FederationCache, EntryPoint, NFBuildAdapterOptions } from '@softarc/native-federation';
+import type { PathToImport } from '@softarc/native-federation/internal';
+export interface NormalizedContextOptions {
+    builderOptions: ApplicationBuilderOptions;
+    context: BuilderContext;
+    entryPoints: EntryPoint[];
+    external: string[];
+    outdir: string;
+    tsConfigPath?: string;
+    mappedPaths: PathToImport;
+    cache: FederationCache<SourceFileCache>;
+    dev: boolean;
+    isMappingOrExposed: boolean;
+    hash: boolean;
+    chunks?: boolean;
+    platform?: 'browser' | 'node';
+    optimizedMappings: boolean;
+}
+export declare function normalizeContextOptions(builderOptions: ApplicationBuilderOptions, context: BuilderContext, adapterOptions: NFBuildAdapterOptions<SourceFileCache>): NormalizedContextOptions;
+//# sourceMappingURL=normalize-context-options.d.ts.map

package/src/utils/normalize-context-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-context-options.d.ts","sourceRoot":"","sources":["../../../src/utils/normalize-context-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAExE,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,yBAAyB,CAAC;IAC1C,OAAO,EAAE,cAAc,CAAC;IACxB,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,YAAY,CAAC;IAC1B,KAAK,EAAE,eAAe,CAAC,eAAe,CAAC,CAAC;IACxC,GAAG,EAAE,OAAO,CAAC;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;IAC9B,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CACrC,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,qBAAqB,CAAC,eAAe,CAAC,GACrD,wBAAwB,CAiB1B"}

package/src/utils/normalize-context-options.js

@@ -0,0 +1,18 @@
+export function normalizeContextOptions(builderOptions, context, adapterOptions) {
+    return {
+        builderOptions,
+        context,
+        entryPoints: adapterOptions.entryPoints,
+        external: adapterOptions.external,
+        outdir: adapterOptions.outdir,
+        tsConfigPath: adapterOptions.tsConfigPath,
+        mappedPaths: adapterOptions.mappedPaths,
+        cache: adapterOptions.cache,
+        dev: !!adapterOptions.dev,
+        isMappingOrExposed: !!adapterOptions.isMappingOrExposed,
+        hash: !!adapterOptions.hash,
+        chunks: adapterOptions.chunks,
+        platform: adapterOptions.platform,
+        optimizedMappings: !!adapterOptions.optimizedMappings,
+    };
+}

package/src/utils/shared-mappings-plugin.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from 'esbuild';
-import type { MappedPath } from '@softarc/native-federation/internal';
-export declare function createSharedMappingsPlugin(mappedPaths: MappedPath[]): Plugin;
+import type { PathToImport } from '@softarc/native-federation/internal';
+export declare function createSharedMappingsPlugin(mappedPaths: PathToImport): Plugin;
 //# sourceMappingURL=shared-mappings-plugin.d.ts.map

package/src/utils/shared-mappings-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-mappings-plugin.d.ts","sourceRoot":"","sources":["../../../src/utils/shared-mappings-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEtE,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,UAAU,EAAE,GAAG,MAAM,CA8B5E"}
+{"version":3,"file":"shared-mappings-plugin.d.ts","sourceRoot":"","sources":["../../../src/utils/shared-mappings-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,SAAS,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAExE,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,YAAY,GAAG,MAAM,CA8B5E"}

package/src/utils/shared-mappings-plugin.js

@@ -4,20 +4,20 @@ export function createSharedMappingsPlugin(mappedPaths) {
         name: 'custom',
         setup(build) {
             build.onResolve({ filter: /^[.]/ }, async (args) => {
-                let mappedPath = null;
+                let mappedPath = undefined;
                 let isSelf = false;
                 if (args.kind === 'import-statement') {
                     const importPath = path.join(args.resolveDir, args.path);
                     if (mappedPaths) {
-                        mappedPath = mappedPaths.find(p => importPath.startsWith(path.dirname(p.path))) ?? null;
+                        mappedPath = Object.keys(mappedPaths).find(p => importPath.startsWith(path.dirname(p)));
                     }
                 }
                 if (mappedPath) {
-                    isSelf = args.importer.startsWith(path.dirname(mappedPath.path));
+                    isSelf = args.importer.startsWith(path.dirname(mappedPath));
                 }
                 if (mappedPath && !isSelf) {
                     return {
-                        path: mappedPath.key,
+                        path: mappedPaths[mappedPath],
                         external: true,
                     };
                 }

package/src/utils/create-compiler-options.d.ts

@@ -1,6 +0,0 @@
-import { type SourceFileCache } from '@angular/build/private';
-export declare function createCompilerPluginOptions(options: any, target: string[], sourceFileCache?: SourceFileCache): {
-    pluginOptions: any[0];
-    styleOptions: any[1];
-};
-//# sourceMappingURL=create-compiler-options.d.ts.map

package/src/utils/create-compiler-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-compiler-options.d.ts","sourceRoot":"","sources":["../../../src/utils/create-compiler-options.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,GAAG,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,eAAe,CAAC,EAAE,eAAe,GAChC;IACD,aAAa,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IACtB,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;CACtB,CAwDA"}