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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular-architects/native-federation-v4",
-  "version": "21.1.6",
+  "version": "21.1.7",
   "generators": "./collection.json",
   "builders": "./builders.json",
   "schematics": "./collection.json",
@@ -9,9 +9,17 @@
     "name": "Manfred Steyer",
     "url": "http://www.angulararchitects.io"
   },
+  "peerDependencies": {
+    "@softarc/native-federation": "^4.0.0-RC8",
+    "@softarc/native-federation-runtime": "^4.0.0-RC8",
+    "@angular-devkit/architect": ">=0.2102.0",
+    "@angular-devkit/build-angular": ">=21.2.0",
+    "@angular-devkit/core": ">=21.2.0",
+    "@angular/build": ">=21.2.0"
+  },
   "dependencies": {
-    "@softarc/native-federation": "4.0.0-RC6",
-    "@softarc/native-federation-runtime": "4.0.0-RC6",
+    "@softarc/native-federation": "4.0.0-RC8",
+    "@softarc/native-federation-runtime": "4.0.0-RC8",
     "@angular-devkit/architect": "^0.2102.0",
     "@angular-devkit/build-angular": "^21.2.0",
     "@angular-devkit/core": "^21.2.0",

package/src/builders/build/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/builder.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC;AAS1C,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAGnB,MAAM,2BAA2B,CAAC;AAiCnC,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAyCnD,wBAAuB,UAAU,CAC/B,gBAAgB,EAAE,eAAe,EACjC,OAAO,EAAE,cAAc,GACtB,aAAa,CAAC,aAAa,CAAC,CAuW9B;wBA6C2C,GAAG;AAA/C,wBAAgD"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/builder.ts"],"names":[],"mappings":"AAAA,OAAO,kCAAkC,CAAC;AAS1C,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,aAAa,EAGnB,MAAM,2BAA2B,CAAC;AAgCnC,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AA2CnD,wBAAuB,UAAU,CAC/B,gBAAgB,EAAE,eAAe,EACjC,OAAO,EAAE,cAAc,GACtB,aAAa,CAAC,aAAa,CAAC,CAkY9B;wBA6C2C,GAAG;AAA/C,wBAAgD"}

package/src/builders/build/builder.js

@@ -6,9 +6,7 @@ import { buildApplication } from '@angular/build';
 import { buildApplicationInternal, serveWithVite, SourceFileCache } from '@angular/build/private';
 import { createBuilder, targetFromTargetString, } from '@angular-devkit/architect';
 import { normalizeOptions } from '@angular-devkit/build-angular/src/builders/dev-server/options.js';
-import { buildForFederation, rebuildForFederation, getExternals, loadFederationConfig, normalizeFederationOptions, setBuildAdapter, createFederationCache,
-// type FederationCache,
- } from '@softarc/native-federation';
+import { buildForFederation, rebuildForFederation, getExternals, loadFederationConfig, normalizeFederationOptions, setBuildAdapter, createFederationCache, } from '@softarc/native-federation';
 import { logger, setLogLevel, RebuildQueue, AbortedError, getDefaultCachePath, } from '@softarc/native-federation/internal';
 import { createAngularBuildAdapter } from '../../utils/angular-esbuild-adapter.js';
 import { existsSync, mkdirSync, rmSync } from 'fs';
@@ -38,6 +36,7 @@ const createInternalAngularBuilder = (_) => (options, context, pluginsOrExtensio
     else {
         extensions = pluginsOrExtensions;
     }
+    // Todo: share cache with Angular builder: https://github.com/angular/angular-cli/pull/32527
     // options.codeBundleCache = nfOptions.federationCache.bundlerCache;
     return buildApplicationInternal(options, context, extensions);
 };
@@ -117,7 +116,7 @@ export async function* runBuilder(nfBuilderOptions, context) {
     const devServerOutputPath = !differentDevServerOutputPath
         ? browserOutputPath
         : path.join(outputOptions.base, outputOptions.browser, localeFilter[0]);
-    const entryPoint = path.join(path.dirname(options.tsConfig), 'src/main.ts');
+    const entryPoint = nfBuilderOptions.entryPoint ?? path.join(path.dirname(options.tsConfig), 'src/main.ts');
     const cachePath = getDefaultCachePath(context.workspaceRoot);
     const nfOptions = normalizeFederationOptions({
         workspaceRoot: context.workspaceRoot,
@@ -188,7 +187,6 @@ export async function* runBuilder(nfBuilderOptions, context) {
         },
     ];
     let first = true;
-    let lastResult;
     if (existsSync(nfOptions.outputPath)) {
         rmSync(nfOptions.outputPath, { recursive: true });
     }
@@ -228,62 +226,85 @@ export async function* runBuilder(nfBuilderOptions, context) {
             indexHtmlTransformer: transformIndexHtml(nfBuilderOptions),
         });
     const rebuildQueue = new RebuildQueue();
+    const builderIterator = builderRun[Symbol.asyncIterator]();
+    let ngBuildStatus = { success: false };
     try {
-        for await (const output of builderRun) {
-            lastResult = output;
-            if (!first && (nfBuilderOptions.dev || watch)) {
-                rebuildQueue
-                    .enqueue(async (signal) => {
-                    if (signal?.aborted) {
-                        throw new AbortedError('Build canceled before starting');
-                    }
-                    await new Promise((resolve, reject) => {
-                        const timeout = setTimeout(resolve, Math.max(10, nfBuilderOptions.rebuildDelay));
-                        if (signal) {
-                            const abortHandler = () => {
-                                clearTimeout(timeout);
-                                reject(new AbortedError('[builder] During delay.'));
-                            };
-                            signal.addEventListener('abort', abortHandler, { once: true });
+        let buildResult = await builderIterator.next();
+        while (!buildResult.done) {
+            if (buildResult.value)
+                ngBuildStatus = buildResult.value;
+            if (!ngBuildStatus.success) {
+                logger.warn('Skipping federation artifacts because Angular build failed.');
+                buildResult = await builderIterator.next();
+            }
+            else if (!first && (nfBuilderOptions.dev || watch)) {
+                const nextOutputPromise = builderIterator.next();
+                const trackResult = await rebuildQueue.track(async (signal) => {
+                    try {
+                        if (signal?.aborted) {
+                            throw new AbortedError('Build canceled before starting');
                         }
-                    });
-                    if (signal?.aborted) {
-                        throw new AbortedError('[builder] Before federation build.');
-                    }
-                    const start = process.hrtime();
-                    // Invalidate all source files, Angular doesn't provide a way to give the invalidated files yet.
-                    const keys = new Set([...nfOptions.federationCache.bundlerCache.keys()].filter(k => !k.includes('node_modules')));
-                    nfOptions.federationCache.bundlerCache.invalidate(keys);
-                    federationResult = await rebuildForFederation(config, nfOptions, externals, [], signal);
-                    if (signal?.aborted) {
-                        throw new AbortedError('[builder] After federation build.');
-                    }
-                    if (hasLocales && localeFilter) {
-                        translateFederationArtifacts(i18n, localeFilter, outputOptions.base, federationResult);
-                    }
-                    if (signal?.aborted) {
-                        throw new AbortedError('[builder] After federation translations.');
-                    }
-                    logger.info('Done!');
-                    if (isLocalDevelopment) {
-                        federationBuildNotifier.broadcastBuildCompletion();
-                    }
-                    logger.measure(start, 'To rebuild the federation artifacts.');
-                })
-                    .catch(error => {
-                    if (error instanceof AbortedError) {
-                        logger.verbose('Rebuild was canceled. Cancellation point: ' + error?.message);
-                        federationBuildNotifier.broadcastBuildCancellation();
+                        await new Promise((resolve, reject) => {
+                            const timeout = setTimeout(resolve, Math.max(10, nfBuilderOptions.rebuildDelay));
+                            if (signal) {
+                                const abortHandler = () => {
+                                    clearTimeout(timeout);
+                                    reject(new AbortedError('[builder] During delay.'));
+                                };
+                                signal.addEventListener('abort', abortHandler, { once: true });
+                            }
+                        });
+                        if (signal?.aborted) {
+                            throw new AbortedError('[builder] Before federation build.');
+                        }
+                        const start = process.hrtime();
+                        // Todo: Invalidate all source files, Angular doesn't provide a way to give the invalidated files yet.
+                        // ref: https://github.com/angular/angular-cli/pull/32527
+                        const keys = [...nfOptions.federationCache.bundlerCache.keys()].filter(k => !k.includes('node_modules'));
+                        federationResult = await rebuildForFederation(config, nfOptions, externals, keys, signal);
+                        if (signal?.aborted) {
+                            throw new AbortedError('[builder] After federation build.');
+                        }
+                        if (hasLocales && localeFilter) {
+                            translateFederationArtifacts(i18n, localeFilter, outputOptions.base, federationResult);
+                        }
+                        if (signal?.aborted) {
+                            throw new AbortedError('[builder] After federation translations.');
+                        }
+                        logger.info('Done!');
+                        if (isLocalDevelopment) {
+                            federationBuildNotifier.broadcastBuildCompletion();
+                        }
+                        logger.measure(start, 'To rebuild the federation artifacts.');
+                        return { success: true };
                     }
-                    else {
+                    catch (error) {
+                        if (error instanceof AbortedError) {
+                            logger.verbose('Rebuild was canceled. Cancellation point: ' + error?.message);
+                            federationBuildNotifier.broadcastBuildCancellation();
+                            return { success: false, cancelled: true };
+                        }
                         logger.error('Federation rebuild failed!');
                         if (options.verbose)
                             console.error(error);
                         if (isLocalDevelopment) {
                             federationBuildNotifier.broadcastBuildError(error);
                         }
+                        return { success: false };
                     }
-                });
+                }, nextOutputPromise);
+                if (trackResult.type === 'completed') {
+                    if (!trackResult.result.cancelled) {
+                        yield { success: trackResult.result.success };
+                    }
+                    buildResult = await nextOutputPromise;
+                }
+                else {
+                    buildResult = trackResult.value;
+                }
+            }
+            else {
+                buildResult = await builderIterator.next();
             }
             first = false;
         }
@@ -295,7 +316,7 @@ export async function* runBuilder(nfBuilderOptions, context) {
             federationBuildNotifier.stopEventServer();
         }
     }
-    yield lastResult || { success: false };
+    yield ngBuildStatus;
 }
 function removeBaseHref(req, baseHref) {
     let url = req.url ?? '';

package/src/builders/build/schema.d.ts

@@ -18,5 +18,6 @@ export interface NfBuilderSchema extends JsonObject {
   ssr: boolean;
   devServer?: boolean;
   chunks?: { enable: boolean; dense: true };
+  entryPoint?: string;
   cacheExternalArtifacts?: boolean;
 } // eslint-disable-line

package/src/builders/build/schema.json

@@ -23,6 +23,9 @@
       "type": "number",
       "default": 0
     },
+    "entryPoint": {
+      "type": "string"
+    },
     "open": {
       "type": "boolean",
       "default": true,

package/src/builders/build/setup-builder-env-variables.js

@@ -3,5 +3,7 @@
  * a shared cache between the compilation steps which
  * improves performance dramatically.
  */
-process.env['NG_BUILD_PARALLEL_TS'] = '0';
+if (!process.env['NG_BUILD_PARALLEL_TS']) {
+    process.env['NG_BUILD_PARALLEL_TS'] = '0';
+}
 export {};

package/src/utils/angular-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 AngularBundleResult {
+    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

@@ -0,0 +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"}

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

@@ -1,6 +1,10 @@
 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';
+export interface EsbuildContextResult {
+    ctx: esbuild.BuildContext;
+    pluginDisposed: Promise<void>;
+}
 export declare function createAngularBuildAdapter(builderOptions: ApplicationBuilderOptions, context: BuilderContext): NFBuildAdapter;
-export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;
 //# 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,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAuBhE,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,yBAAyB,EACzC,OAAO,EAAE,cAAc,GACtB,cAAc,CAwHhB;AAoQD,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,74 +1,101 @@
-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';
+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) {
+    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(builderOptions, context) {
-    const contextCache = new Map();
+    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;
         setNgServerMode();
-        if (contextCache.has(bundleName)) {
+        if (bundleContextCache.has(bundleName)) {
             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 { 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,
-            entryPoints,
-            workspaceRoot: context.workspaceRoot,
         });
     };
     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 +107,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/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"}

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

@@ -0,0 +1,113 @@
+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';
+import { createSharedMappingsPlugin } from './shared-mappings-plugin.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(builderOptions, context, entryPoints, external, outdir, mappedPaths, cache, dev, hash = false, chunks, platform) {
+    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),
+            ...(mappedPaths && mappedPaths.length > 0 ? [createSharedMappingsPlugin(mappedPaths)] : []),
+            commonjsPlugin(),
+        ],
+        define: {
+            ...(!dev ? { ngDevMode: '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/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"}

package/src/utils/create-compiler-options.js

@@ -1,41 +0,0 @@
-// Taken from https://github.com/angular/angular-cli/blob/main/packages/angular/build/src/tools/esbuild/compiler-plugin-options.ts
-// Currently, this type cannot be accessed from the outside
-export function createCompilerPluginOptions(options, target, sourceFileCache) {
-    const { workspaceRoot, optimizationOptions, sourcemapOptions, tsconfig, outputNames, fileReplacements, externalDependencies, preserveSymlinks, stylePreprocessorOptions, advancedOptimizations, inlineStyleLanguage, jit, cacheOptions, tailwindConfiguration, postcssConfiguration, publicPath, } = options;
-    return {
-        // JS/TS options
-        pluginOptions: {
-            sourcemap: !!sourcemapOptions.scripts && (sourcemapOptions.hidden ? 'external' : true),
-            thirdPartySourcemaps: sourcemapOptions.vendor,
-            tsconfig,
-            jit,
-            advancedOptimizations,
-            fileReplacements,
-            sourceFileCache,
-            loadResultCache: sourceFileCache?.loadResultCache,
-            incremental: !!options.watch,
-        },
-        // Component stylesheet options
-        styleOptions: {
-            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: stylePreprocessorOptions?.includePaths,
-            sass: stylePreprocessorOptions?.sass,
-            externalDependencies,
-            target,
-            inlineStyleLanguage,
-            preserveSymlinks,
-            tailwindConfiguration,
-            postcssConfiguration,
-            cacheOptions,
-            publicPath,
-        },
-    };
-}

package/src/utils/mem-resuts.d.ts

@@ -1,29 +0,0 @@
-import type { OutputFile } from 'esbuild';
-export interface BuildResult {
-    fileName: string;
-    get(): Uint8Array | Buffer;
-}
-export declare class EsBuildResult implements BuildResult {
-    private outputFile;
-    private fullOutDir?;
-    get fileName(): string;
-    constructor(outputFile: OutputFile, fullOutDir?: string | undefined);
-    get(): Uint8Array;
-}
-export interface NgCliAssetFile {
-    source: string;
-    destination: string;
-}
-export declare class NgCliAssetResult implements BuildResult {
-    get fileName(): string;
-    private file;
-    constructor(assetFile: NgCliAssetFile);
-    get(): Buffer;
-}
-export declare class MemResults {
-    private map;
-    add(result: BuildResult[]): void;
-    get(fileName: string): BuildResult | undefined;
-    getFileNames(): string[];
-}
-//# sourceMappingURL=mem-resuts.d.ts.map

package/src/utils/mem-resuts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mem-resuts.d.ts","sourceRoot":"","sources":["../../../src/utils/mem-resuts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1C,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,IAAI,UAAU,GAAG,MAAM,CAAC;CAC5B;AAED,qBAAa,aAAc,YAAW,WAAW;IASnC,OAAO,CAAC,UAAU;IAAc,OAAO,CAAC,UAAU,CAAC;IAR/D,IAAI,QAAQ,WAMX;gBAEmB,UAAU,EAAE,UAAU,EAAU,UAAU,CAAC,EAAE,MAAM,YAAA;IAEvE,GAAG,IAAI,UAAU;CAGlB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qBAAa,gBAAiB,YAAW,WAAW;IAClD,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,OAAO,CAAC,IAAI,CAAiB;gBAEjB,SAAS,EAAE,cAAc;IAIrC,GAAG,IAAI,MAAM;CAGd;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,GAAG,CAAkC;IAEtC,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI;IAMhC,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI9C,YAAY,IAAI,MAAM,EAAE;CAGhC"}

package/src/utils/mem-resuts.js

@@ -1,50 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-export class EsBuildResult {
-    outputFile;
-    fullOutDir;
-    get fileName() {
-        if (this.fullOutDir) {
-            return unify(path.relative(this.fullOutDir, this.outputFile.path));
-        }
-        else {
-            return unify(this.outputFile.path);
-        }
-    }
-    constructor(outputFile, fullOutDir) {
-        this.outputFile = outputFile;
-        this.fullOutDir = fullOutDir;
-    }
-    get() {
-        return this.outputFile.contents;
-    }
-}
-export class NgCliAssetResult {
-    get fileName() {
-        return unify(this.file.destination);
-    }
-    file;
-    constructor(assetFile) {
-        this.file = assetFile;
-    }
-    get() {
-        return fs.readFileSync(this.file.source);
-    }
-}
-export class MemResults {
-    map = new Map();
-    add(result) {
-        for (const file of result) {
-            this.map.set(file.fileName, file);
-        }
-    }
-    get(fileName) {
-        return this.map.get(fileName);
-    }
-    getFileNames() {
-        return [...this.map.keys()];
-    }
-}
-function unify(path) {
-    return path?.replace(/\\/g, '/');
-}