module-federation-angular-adapter 0.2200.0

package/src/tools/mf/build-for-federation.js

@@ -0,0 +1,75 @@
+import { normalizeContextOptions } from '../../utils/normalize-context-options.js';
+import { createFederationEsbuildContext } from './federation-side-build.js';
+import { toExposedEntryPoints, } from './federation-entry-points.js';
+/** Shared-mappings → entry points (mirrors NF's `bundleExposedAndMappings`). */
+function toMappingEntryPoints(sharedMappings = {}) {
+    return Object.entries(sharedMappings).map(([entryPoint, mappedImport]) => ({
+        fileName: entryPoint,
+        outName: mappedImport.replace(/[^A-Za-z0-9]/g, '_') + '.js',
+        key: mappedImport,
+    }));
+}
+/** NF normalized config → the MF plugin's `FederationConfigInput` (exposes value → file path). */
+function toFederationConfigInput(config) {
+    const exposes = {};
+    for (const [key, expose] of Object.entries(config.exposes ?? {})) {
+        exposes[key] = expose.file;
+    }
+    return {
+        name: config.name,
+        filename: config.filename,
+        exposes,
+        shared: config.shared,
+        remotes: config.remotes,
+    };
+}
+export async function createMfFederationBuilder(config, fedOptions, externals, ctx) {
+    const entryPoints = [
+        ...toMappingEntryPoints(config.sharedMappings),
+        ...toExposedEntryPoints(config.exposes),
+    ];
+    const options = normalizeContextOptions(ctx.builderOptions, ctx.context, {
+        entryPoints,
+        outdir: fedOptions.outputPath,
+        tsConfigPath: fedOptions.tsConfig,
+        external: externals,
+        dev: !!fedOptions.dev,
+        watch: fedOptions.watch,
+        mappedPaths: config.sharedMappings ?? {},
+        chunks: config.chunks,
+        hash: !fedOptions.dev,
+        optimizedMappings: !!config.features?.ignoreUnusedDeps,
+        isMappingOrExposed: true,
+        cache: fedOptions.federationCache,
+    });
+    const { ctx: buildContext, pluginDisposed } = await createFederationEsbuildContext(options, toFederationConfigInput(config));
+    const runWrite = async () => {
+        const result = await buildContext.rebuild();
+        // write:true → esbuild emitted the chunks + container, and the MF plugin's
+        // onEnd rewrote the container (module map) + wrote mf-manifest.json. Collect
+        // the emitted files from the metafile (the plugin forces metafile:true).
+        const writtenFiles = result.metafile ? Object.keys(result.metafile.outputs) : [];
+        return {
+            name: config.name,
+            exposes: Object.keys(config.exposes ?? {}),
+            writtenFiles,
+        };
+    };
+    let disposed = false;
+    return {
+        build: runWrite,
+        async rebuild(modifiedFiles = []) {
+            options.cache.bundlerCache.invalidate(new Set(modifiedFiles));
+            return runWrite();
+        },
+        // Idempotent: the build builder disposes once for the #47 TS-state reset
+        // (non-watch) and again in its final cleanup, so guard against double-dispose.
+        async dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            await buildContext.dispose();
+            await pluginDisposed;
+        },
+    };
+}

package/src/tools/mf/federation-entry-points.d.ts

@@ -0,0 +1,23 @@
+/**
+ * esbuild entry-point descriptor for the side build. Structurally matches NF's
+ * `EntryPoint` (`{ fileName, outName, key? }`) so it's assignable to
+ * `createAngularEsbuildContext`'s param, but declared locally to survive the
+ * Phase-3 NF removal.
+ */
+export interface FederationEntryPoint {
+    fileName: string;
+    outName: string;
+    key?: string;
+}
+/** A config `exposes` entry — only the source `file` is needed to build it. */
+export interface ExposeInput {
+    file: string;
+}
+/**
+ * Derive the side-build entry points from a federation config's `exposes`
+ * (M2.1). Mirrors NF's `bundleExposedAndMappings`:
+ * `{ fileName: expose.file, outName: key + '.js', key }`. Shared-mappings
+ * entries (if still used) are concatenated by the caller.
+ */
+export declare function toExposedEntryPoints(exposes?: Record<string, ExposeInput>): FederationEntryPoint[];
+//# sourceMappingURL=federation-entry-points.d.ts.map

package/src/tools/mf/federation-entry-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-entry-points.d.ts","sourceRoot":"","sources":["../../../../src/tools/mf/federation-entry-points.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAM,GACxC,oBAAoB,EAAE,CAMxB"}

package/src/tools/mf/federation-entry-points.js

@@ -0,0 +1,13 @@
+/**
+ * Derive the side-build entry points from a federation config's `exposes`
+ * (M2.1). Mirrors NF's `bundleExposedAndMappings`:
+ * `{ fileName: expose.file, outName: key + '.js', key }`. Shared-mappings
+ * entries (if still used) are concatenated by the caller.
+ */
+export function toExposedEntryPoints(exposes = {}) {
+    return Object.entries(exposes).map(([key, expose]) => ({
+        fileName: expose.file,
+        outName: key + '.js',
+        key,
+    }));
+}

package/src/tools/mf/federation-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'esbuild';
+import { type FederationConfigInput } from './to-plugin-config.js';
+/**
+ * The esbuild plugin injected into the Angular esbuild context (M2.1 keystone:
+ * one-pass composition). It wraps the exposed Angular modules — already compiled
+ * by the co-present Angular compiler plugin — into the MF container and emits
+ * `remoteEntry.js` + `mf-manifest.json`. Externals/shared resolution flows
+ * through es-module-shims import maps (finding #6).
+ */
+export declare function createFederationPlugin(cfg: FederationConfigInput, filename?: string): Plugin;
+//# sourceMappingURL=federation-plugin.d.ts.map

package/src/tools/mf/federation-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-plugin.d.ts","sourceRoot":"","sources":["../../../../src/tools/mf/federation-plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAoB,KAAK,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAErF;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAER"}

package/src/tools/mf/federation-plugin.js

@@ -0,0 +1,12 @@
+import { moduleFederationPlugin } from '@module-federation/esbuild/plugin';
+import { toMfPluginConfig } from './to-plugin-config.js';
+/**
+ * The esbuild plugin injected into the Angular esbuild context (M2.1 keystone:
+ * one-pass composition). It wraps the exposed Angular modules — already compiled
+ * by the co-present Angular compiler plugin — into the MF container and emits
+ * `remoteEntry.js` + `mf-manifest.json`. Externals/shared resolution flows
+ * through es-module-shims import maps (finding #6).
+ */
+export function createFederationPlugin(cfg, filename) {
+    return moduleFederationPlugin(toMfPluginConfig(cfg, filename));
+}

package/src/tools/mf/federation-side-build.d.ts

@@ -0,0 +1,21 @@
+import type { NormalizedContextOptions } from '../../utils/normalize-context-options.js';
+import { createAngularEsbuildContext } from '../esbuild/angular-bundler.js';
+import type { FederationConfigInput } from './to-plugin-config.js';
+/**
+ * MF side-build context (M2.1 driver). Replaces NF's `buildForFederation` build
+ * path: reuses the Angular compiler esbuild context and injects
+ * `moduleFederationPlugin` as an extra plugin — the one-pass composition proven
+ * feasible from the plugin source (the compiler plugin compiles exposed `.ts`;
+ * the MF plugin wraps the container; the nested shared sub-build is
+ * commonjs-only, so the compiler never runs twice).
+ *
+ * Returns the esbuild `BuildContext` + the compiler's `pluginDisposed`, mirroring
+ * `createAngularEsbuildContext` so the existing orchestration loop (rebuild
+ * queue, dispose) drives it unchanged.
+ *
+ * ⚠️ End-to-end artifact emission is only verifiable against a real Angular app
+ * (absent in this sandbox — same limit as the M1.7 e2e); this is code-complete
+ * and type-checked, emit-proof deferred.
+ */
+export declare function createFederationEsbuildContext(options: NormalizedContextOptions, federationConfig: FederationConfigInput): ReturnType<typeof createAngularEsbuildContext>;
+//# sourceMappingURL=federation-side-build.d.ts.map

package/src/tools/mf/federation-side-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-side-build.d.ts","sourceRoot":"","sources":["../../../../src/tools/mf/federation-side-build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0CAA0C,CAAC;AACzF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,wBAAwB,EACjC,gBAAgB,EAAE,qBAAqB,GACtC,UAAU,CAAC,OAAO,2BAA2B,CAAC,CAQhD"}

package/src/tools/mf/federation-side-build.js

@@ -0,0 +1,27 @@
+import { createAngularEsbuildContext } from '../esbuild/angular-bundler.js';
+import { createFederationPlugin } from './federation-plugin.js';
+/**
+ * MF side-build context (M2.1 driver). Replaces NF's `buildForFederation` build
+ * path: reuses the Angular compiler esbuild context and injects
+ * `moduleFederationPlugin` as an extra plugin — the one-pass composition proven
+ * feasible from the plugin source (the compiler plugin compiles exposed `.ts`;
+ * the MF plugin wraps the container; the nested shared sub-build is
+ * commonjs-only, so the compiler never runs twice).
+ *
+ * Returns the esbuild `BuildContext` + the compiler's `pluginDisposed`, mirroring
+ * `createAngularEsbuildContext` so the existing orchestration loop (rebuild
+ * queue, dispose) drives it unchanged.
+ *
+ * ⚠️ End-to-end artifact emission is only verifiable against a real Angular app
+ * (absent in this sandbox — same limit as the M1.7 e2e); this is code-complete
+ * and type-checked, emit-proof deferred.
+ */
+export function createFederationEsbuildContext(options, federationConfig) {
+    // `write: true` (M2.2): the MF plugin's `onEnd` reads the emitted container off
+    // disk to inject the module map, so it cannot run under the NF `write:false` +
+    // writeResult flow. esbuild writes the chunks/container/manifest to `outdir`.
+    return createAngularEsbuildContext(options, {
+        extraPlugins: [createFederationPlugin(federationConfig)],
+        write: true,
+    });
+}

package/src/tools/mf/to-plugin-config.d.ts

@@ -0,0 +1,37 @@
+import type { moduleFederationPlugin } from '@module-federation/esbuild/plugin';
+/**
+ * Config object accepted by `@module-federation/esbuild`'s `moduleFederationPlugin`
+ * (its `NormalizedFederationConfig`). Derived via `Parameters<>` so we don't reach
+ * into the plugin's `dist/lib/config/*` internals.
+ */
+export type MfPluginConfig = Parameters<typeof moduleFederationPlugin>[0];
+/**
+ * Minimal shape we read off a *normalized* federation config to drive the MF
+ * side build. Declared locally (not imported from `@softarc/native-federation`)
+ * so this mapper survives the Phase-3 NF removal — both NF's and MF's own
+ * normalized configs satisfy it.
+ */
+export interface FederationConfigInput {
+    name: string;
+    filename?: string;
+    exposes?: Record<string, string>;
+    shared?: Record<string, FederationSharedInput>;
+    remotes?: Record<string, string>;
+}
+export interface FederationSharedInput {
+    singleton?: boolean;
+    strictVersion?: boolean;
+    /** Concrete range by the normalized stage (NF resolves `'auto'` upstream). */
+    requiredVersion?: string;
+    version?: string;
+    eager?: boolean;
+    includeSecondaries?: boolean;
+}
+/**
+ * Map a normalized federation config → `moduleFederationPlugin` options (the
+ * config half of M2.1). Pairs with the proven esbuild invocation (M0.1 / the
+ * in-workspace re-proof) to form the side build. The plugin emits
+ * `remoteEntry.js` + `mf-manifest.json`.
+ */
+export declare function toMfPluginConfig(cfg: FederationConfigInput, filename?: string): MfPluginConfig;
+//# sourceMappingURL=to-plugin-config.d.ts.map

package/src/tools/mf/to-plugin-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-plugin-config.d.ts","sourceRoot":"","sources":["../../../../src/tools/mf/to-plugin-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAEhF;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC;AAG1E;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,8EAA8E;IAC9E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAqBD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,qBAAqB,EAC1B,QAAQ,SAAmB,GAC1B,cAAc,CAQhB"}

package/src/tools/mf/to-plugin-config.js

@@ -0,0 +1,33 @@
+function mapShared(shared) {
+    const out = {};
+    for (const [pkg, cfg] of Object.entries(shared ?? {})) {
+        out[pkg] = {
+            singleton: cfg.singleton ?? false,
+            strictVersion: cfg.strictVersion ?? false,
+            // The plugin's NormalizedSharedConfig requires a string here (no `false`,
+            // unlike the runtime). Fall back to `'*'` when unresolved.
+            requiredVersion: cfg.requiredVersion ?? '*',
+            version: cfg.version,
+            eager: cfg.eager,
+            // ✅ Spike-confirmed (finding #4): the esbuild plugin DOES support
+            // `includeSecondaries` — so it maps 1:1, contra M3.1's table.
+            includeSecondaries: cfg.includeSecondaries,
+        };
+    }
+    return out;
+}
+/**
+ * Map a normalized federation config → `moduleFederationPlugin` options (the
+ * config half of M2.1). Pairs with the proven esbuild invocation (M0.1 / the
+ * in-workspace re-proof) to form the side build. The plugin emits
+ * `remoteEntry.js` + `mf-manifest.json`.
+ */
+export function toMfPluginConfig(cfg, filename = 'remoteEntry.js') {
+    return {
+        name: cfg.name,
+        filename: cfg.filename ?? filename,
+        exposes: cfg.exposes ?? {},
+        shared: mapShared(cfg.shared),
+        remotes: cfg.remotes,
+    };
+}

package/src/utils/check-for-invalid-imports.d.ts

@@ -0,0 +1,2 @@
+export declare function checkForInvalidImports(importList: string[], type: string): void;
+//# sourceMappingURL=check-for-invalid-imports.d.ts.map

package/src/utils/check-for-invalid-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-for-invalid-imports.d.ts","sourceRoot":"","sources":["../../../src/utils/check-for-invalid-imports.ts"],"names":[],"mappings":"AAIA,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,QAiCxE"}

package/src/utils/check-for-invalid-imports.js

@@ -0,0 +1,29 @@
+import { logger } from '@softarc/native-federation/internal';
+const ALLOWED_FILE_EXTENSIONS = new Set(['mjs', 'js', 'mts', 'ts', 'jsx', 'tsx', 'json']);
+export function checkForInvalidImports(importList, type) {
+    const importsWithDot = [];
+    for (const mappingImport of importList) {
+        if (!mappingImport.includes('.')) {
+            continue;
+        }
+        const queryIndex = mappingImport.search(/[?#]/);
+        const sanitizedImport = queryIndex >= 0 ? mappingImport.slice(0, queryIndex) : mappingImport;
+        const segmentStart = sanitizedImport.lastIndexOf('/') + 1;
+        const lastSegment = sanitizedImport.slice(segmentStart);
+        const dotIndex = lastSegment.lastIndexOf('.');
+        if (dotIndex < 0) {
+            continue;
+        }
+        const extension = lastSegment.slice(dotIndex + 1);
+        if (!ALLOWED_FILE_EXTENSIONS.has(extension)) {
+            importsWithDot.push(mappingImport);
+        }
+    }
+    if (importsWithDot.length > 0) {
+        importsWithDot.forEach(e => {
+            logger.warn(`Import '${e}' contains a bad dot (.) import.`);
+        });
+        logger.debug('Bad import issue: https://github.com/vitejs/vite/issues/21036');
+        throw new Error(`Invalid '${type}' config. Invalid imports paths detected, consider using a barrel import instead. `);
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { ApplicationBuilderOptions } from '@angular/build';
+/**
+ * Vendored from `@angular/build` (`normalize-optimization.ts`, `normalize-source-maps.ts`).
+ * These helpers aren't on the public or `/private` export surface.
+ *
+ * Types are derived from the public `ApplicationBuilderOptions`. Emitted declarations don't
+ * reference Angular's internal schema module.
+ */
+type Optimization = NonNullable<ApplicationBuilderOptions['optimization']>;
+type OptimizationObject = Extract<Optimization, object>;
+type Styles = Extract<NonNullable<OptimizationObject['styles']>, object>;
+type Fonts = Extract<NonNullable<OptimizationObject['fonts']>, object>;
+type NormalizedOptimization = Required<Omit<OptimizationObject, 'fonts' | 'styles'>> & {
+    fonts: Fonts;
+    styles: Styles;
+};
+type SourceMap = NonNullable<ApplicationBuilderOptions['sourceMap']>;
+type NormalizedSourceMap = Extract<SourceMap, object>;
+export declare function normalizeOptimization(optimization?: Optimization): NormalizedOptimization;
+export declare function normalizeSourceMaps(sourceMap: SourceMap): NormalizedSourceMap;
+export {};
+//# sourceMappingURL=normalize-build-options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-build-options.d.ts","sourceRoot":"","sources":["../../../src/utils/normalize-build-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE;;;;;;GAMG;AAEH,KAAK,YAAY,GAAG,WAAW,CAAC,yBAAyB,CAAC,cAAc,CAAC,CAAC,CAAC;AAC3E,KAAK,kBAAkB,GAAG,OAAO,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;AACxD,KAAK,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACzE,KAAK,KAAK,GAAG,OAAO,CAAC,WAAW,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAEvE,KAAK,sBAAsB,GAAG,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,CAAC,CAAC,GAAG;IACrF,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,SAAS,GAAG,WAAW,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAC,CAAC;AACrE,KAAK,mBAAmB,GAAG,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAEtD,wBAAgB,qBAAqB,CAAC,YAAY,GAAE,YAAmB,GAAG,sBAAsB,CAkC/F;AAED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,GAAG,mBAAmB,CAc7E"}

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

@@ -0,0 +1,45 @@
+export function normalizeOptimization(optimization = true) {
+    if (typeof optimization === 'object') {
+        const styleOptimization = !!optimization.styles;
+        return {
+            scripts: !!optimization.scripts,
+            styles: typeof optimization.styles === 'object'
+                ? optimization.styles
+                : {
+                    minify: styleOptimization,
+                    removeSpecialComments: styleOptimization,
+                    inlineCritical: styleOptimization,
+                },
+            fonts: typeof optimization.fonts === 'object'
+                ? optimization.fonts
+                : {
+                    inline: !!optimization.fonts,
+                },
+        };
+    }
+    return {
+        scripts: optimization,
+        styles: {
+            minify: optimization,
+            inlineCritical: optimization,
+            removeSpecialComments: optimization,
+        },
+        fonts: {
+            inline: optimization,
+        },
+    };
+}
+export function normalizeSourceMaps(sourceMap) {
+    const scripts = typeof sourceMap === 'object' ? sourceMap.scripts : sourceMap;
+    const styles = typeof sourceMap === 'object' ? sourceMap.styles : sourceMap;
+    const hidden = (typeof sourceMap === 'object' && sourceMap.hidden) || false;
+    const vendor = (typeof sourceMap === 'object' && sourceMap.vendor) || false;
+    const sourcesContent = typeof sourceMap === 'object' ? sourceMap.sourcesContent : sourceMap;
+    return {
+        vendor,
+        hidden,
+        scripts,
+        styles,
+        sourcesContent,
+    };
+}

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

@@ -0,0 +1,24 @@
+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';
+import type { NfInternalOptions } from '../builders/build/schema';
+export interface NormalizedContextOptions {
+    builderOptions: ApplicationBuilderOptions & NfInternalOptions;
+    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 & NfInternalOptions, 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;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,MAAM,WAAW,wBAAwB;IACvC,cAAc,EAAE,yBAAyB,GAAG,iBAAiB,CAAC;IAC9D,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,GAAG,iBAAiB,EAC7D,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,
+    };
+}