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

package/src/utils/angular-bundler.js

@@ -0,0 +1,167 @@
+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) {
+    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);
+        }
+    }
+    tsConfigPath = createTsConfigForFederation(workspaceRoot, tsConfigPath, entryPoints, optimizedMappings);
+    const pluginOptions = {
+        sourcemap: !!sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
+        thirdPartySourcemaps: sourcemapOptions.vendor,
+        tsconfig: tsConfigPath,
+        jit: false,
+        advancedOptimizations: !dev,
+        fileReplacements,
+        sourceFileCache: cache.bundlerCache,
+        loadResultCache: cache.bundlerCache.loadResultCache,
+        incremental: true,
+        includeTestMetadata: !optimizationOptions.scripts,
+    };
+    const stylesheetBundlerOptions = {
+        workspaceRoot,
+        inlineFonts: !!optimizationOptions.fonts.inline,
+        optimization: !!optimizationOptions.styles.minify,
+        sourcemap: 
+        // Hidden component stylesheet sourcemaps are inaccessible which is effectively
+        // the same as being disabled. Disabling has the advantage of avoiding the overhead
+        // of sourcemap processing.
+        sourcemapOptions.styles && !sourcemapOptions.hidden ? 'linked' : false,
+        outputNames,
+        includePaths: builderOptions.stylePreprocessorOptions?.includePaths,
+        sass: builderOptions?.stylePreprocessorOptions?.sass,
+        externalDependencies: external,
+        target,
+        inlineStyleLanguage: builderOptions.inlineStyleLanguage ?? 'css',
+        preserveSymlinks: builderOptions.preserveSymlinks,
+        tailwindConfiguration,
+        postcssConfiguration,
+        cacheOptions: {
+            enabled: true,
+            basePath: cache.cachePath,
+            path: cache.cachePath,
+        },
+    };
+    const commonjsPluginModule = await import('@chialab/esbuild-plugin-commonjs');
+    const commonjsPlugin = commonjsPluginModule.default;
+    stylesheetBundlerOptions.externalDependencies = [];
+    const [compilerPlugin, pluginDisposed] = createAwaitableCompilerPlugin(pluginOptions, stylesheetBundlerOptions);
+    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: 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'),
+    };
+}
+/**
+ * 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

@@ -2,9 +2,9 @@ import { type NFBuildAdapter } from '@softarc/native-federation';
 import * as esbuild from 'esbuild';
 import type { BuilderContext } from '@angular-devkit/architect';
 import type { ApplicationBuilderOptions } from '@angular/build';
-import { type RebuildEvents } from './rebuild-events.js';
-export type MemResultHandler = (outfiles: esbuild.OutputFile[], outdir?: string) => void;
-export declare function setMemResultHandler(handler: MemResultHandler): void;
-export declare function createAngularBuildAdapter(builderOptions: ApplicationBuilderOptions, context: BuilderContext, rebuildRequested?: RebuildEvents): NFBuildAdapter;
-export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;
+export interface EsbuildContextResult {
+    ctx: esbuild.BuildContext;
+    pluginDisposed: Promise<void>;
+}
+export declare function createAngularBuildAdapter(builderOptions: 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":"AAAA,OAAO,EACL,KAAK,cAAc,EAIpB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAWnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAQhE,OAAO,EAAE,KAAK,aAAa,EAAe,MAAM,qBAAqB,CAAC;AAMtE,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAKzF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAEnE;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,EACvB,gBAAgB,GAAE,aAAiC,GAClD,cAAc,CA2FhB;AAkSD,wBAAgB,aAAa,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC,CAErE"}
+{"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"}

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

@@ -1,276 +1,31 @@
-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 { RebuildHubs } from './rebuild-events.js';
-import JSON5 from 'json5';
-import { isDeepStrictEqual } from 'node:util';
-import { createAwaitableCompilerPlugin } from './create-awaitable-compiler-plugin.js';
-let _memResultHandler;
-// Todo: figure out if still necessary
-export function setMemResultHandler(handler) {
-    _memResultHandler = handler;
-}
-export function createAngularBuildAdapter(builderOptions, context, rebuildRequested = new RebuildHubs()) {
-    return async (options) => {
-        const { entryPoints, tsConfigPath, external, outdir, mappedPaths, kind, watch, dev, hash, chunks, platform, optimizedMappings, signal, } = options;
-        setNgServerMode();
-        const files = await runEsbuild(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, watch, rebuildRequested, dev, kind, chunks, hash, undefined, undefined, undefined, platform, optimizedMappings, signal);
-        if (kind === 'shared-package') {
-            const scriptFiles = files.filter(f => f.endsWith('.js') || f.endsWith('.mjs'));
-            for (const file of scriptFiles) {
-                link(file, !!dev);
-            }
-        }
-        return files.map(fileName => ({ fileName }));
-    };
-    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 runEsbuild(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, watch, rebuildRequested = new RebuildHubs(), dev, kind, chunks, hash = false, plugins = null, absWorkingDir = undefined, logLevel = 'warning', platform, optimizedMappings, signal) {
-    if (signal?.aborted) {
-        throw new AbortedError('[angular-esbuild-adapter] Before building');
-    }
-    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,
-    }, target, undefined);
-    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,
-        absWorkingDir,
-        external,
-        logLevel,
-        bundle: true,
-        sourcemap: sourcemapOptions.scripts,
-        minify: !dev,
-        supported: {
-            'async-await': false,
-            'object-rest-spread': false,
-        },
-        splitting: chunks, //kind === 'mapping-or-exposed',
-        platform: platform ?? 'browser',
-        format: 'esm',
-        target: target,
-        logLimit: kind === 'shared-package' ? 1 : 0,
-        plugins: 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);
-    try {
-        const abortHandler = async () => {
-            await ctx.cancel();
-            await ctx.dispose();
-            await pluginDisposed;
-        };
-        if (signal) {
-            signal.addEventListener('abort', abortHandler, { once: true });
-        }
-        const result = await ctx.rebuild();
-        const memOnly = dev && kind === 'mapping-or-exposed' && !!_memResultHandler;
-        const writtenFiles = writeResult(result, outdir, !!memOnly);
-        if (watch) {
-            // Also hardcoded disabled?
-            registerForRebuilds(kind ?? 'shared-package', rebuildRequested, ctx, outdir, !!memOnly);
-        }
-        else {
-            if (signal)
-                signal.removeEventListener('abort', abortHandler);
-            await ctx.dispose();
-            await pluginDisposed;
-        }
-        return writtenFiles;
-    }
-    catch (error) {
-        // ESBuild throws an error if the request is cancelled.
-        // if it is, it's changed to an 'AbortedError'
-        if (signal?.aborted && error instanceof Error && error.message.includes('canceled')) {
-            throw new AbortedError('[runEsbuild] ESBuild was canceled.');
-        }
-        throw error;
-    }
-}
-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;
+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);
 }
-function writeResult(result, outdir, memOnly) {
+function writeResult(result, outdir) {
     const writtenFiles = [];
-    if (memOnly) {
-        _memResultHandler(result.outputFiles ?? [], outdir);
-    }
     for (const outFile of result.outputFiles ?? []) {
         const fileName = path.basename(outFile.path);
         const filePath = path.join(outdir, fileName);
-        if (!memOnly) {
-            fs.writeFileSync(filePath, outFile.text);
-        }
+        fs.writeFileSync(filePath, outFile.text);
         writtenFiles.push(filePath);
     }
-    if (!memOnly) {
-        // for (const asset of result.outputFiles)
-    }
     return writtenFiles;
 }
-function registerForRebuilds(kind, rebuildRequested, ctx, outdir, memOnly) {
-    if (kind !== 'shared-package') {
-        rebuildRequested.rebuild.register(async () => {
-            const result = await ctx.rebuild();
-            writeResult(result, outdir, memOnly);
-        });
-    }
-}
-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.
-//
+/**
+ * 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;`;
@@ -287,3 +42,68 @@ function setNgServerMode() {
         console.error('Error patching file ', fileToPatch, '\nIs it write-protected?');
     }
 }
+export function createAngularBuildAdapter(builderOptions, context) {
+    const bundleContextCache = new Map();
+    const dispose = async (name) => {
+        if (name) {
+            if (!bundleContextCache.has(name))
+                throw new Error(`Could not dispose of non-existing build '${name}'`);
+            const entry = bundleContextCache.get(name);
+            await entry.ctx.dispose();
+            await entry.pluginDisposed;
+            bundleContextCache.delete(name);
+            return;
+        }
+        const disposals = [];
+        for (const [, entry] of bundleContextCache) {
+            disposals.push((async () => {
+                await entry.ctx.dispose();
+                await entry.pluginDisposed;
+            })());
+        }
+        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;
+        setNgServerMode();
+        if (bundleContextCache.has(bundleName)) {
+            return;
+        }
+        const { ctx, pluginDisposed } = await createEsbuildContext(builderOptions, context, entryPoints, external, outdir, tsConfigPath, mappedPaths, cache, dev, isNodeModules, hash, chunks, platform, optimizedMappings);
+        bundleContextCache.set(bundleName, {
+            ctx,
+            pluginDisposed,
+            outdir,
+            cache,
+            isNodeModules,
+            dev: !!dev,
+            name: bundleName,
+        });
+    };
+    const build = async (name, opts = {}) => {
+        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 {
+            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) {
+            if (opts?.signal?.aborted && error instanceof Error && error.message.includes('canceled')) {
+                throw new AbortedError('[build] ESBuild rebuild was canceled.');
+            }
+            throw error;
+        }
+    };
+    return { setup, build, dispose };
+}

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

@@ -0,0 +1,12 @@
+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 NodeModulesBundleResult {
+    ctx: esbuild.BuildContext;
+    pluginDisposed: Promise<void>;
+}
+export declare function createNodeModulesEsbuildContext(builderOptions: ApplicationBuilderOptions, context: BuilderContext, entryPoints: EntryPoint[], external: string[], outdir: string, mappedPaths: MappedPath[], cache: FederationCache<SourceFileCache>, dev?: boolean, hash?: boolean, chunks?: boolean, platform?: 'browser' | 'node'): Promise<NodeModulesBundleResult>;
+//# 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;AAInC,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAIhE,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;AAwDtE,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,OAAO,CAAC,YAAY,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAaD,wBAAsB,+BAA+B,CACnD,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,UAAU,EAAE,EACzB,QAAQ,EAAE,MAAM,EAAE,EAClB,MAAM,EAAE,MAAM,EACd,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,GAC5B,OAAO,CAAC,uBAAuB,CAAC,CA4ElC"}