module-federation-angular-adapter 0.2200.0

package/src/builders/build/get-externals.d.ts

@@ -0,0 +1,18 @@
+import { type SharedConfig } from '../../index.js';
+/**
+ * MF equivalent of NF's `getExternals` (host path, M1.5): the packages the
+ * Angular app build must mark `external` so they resolve from the shared scope
+ * (es-module-shims import map, finding #6) instead of being bundled. For a pure
+ * host this is exactly the shared singleton set.
+ *
+ * Mirrors NF's trivial `[...Object.keys(shared), ...sharedMappings, ...externals]`,
+ * MF-shaped: the keys of the MF `shared` map (+ any extra explicit externals).
+ *
+ * ⚠️ The builder call-site swap (replacing `getExternals(normalized.config)` at
+ * `builder.ts:297`) is performed in **M2.1**, not here: that line and
+ * `buildForFederation` (`builder.ts:425`) consume the *same* `normalized.config`,
+ * so the externals source and the side-build's `shared` must switch to MF
+ * together — otherwise the host externalizes deps nothing provides.
+ */
+export declare function getHostExternals(shared?: SharedConfig, extraExternals?: string[]): string[];
+//# sourceMappingURL=get-externals.d.ts.map

package/src/builders/build/get-externals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-externals.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/get-externals.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3E;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,GAAE,YAAqC,EAC7C,cAAc,GAAE,MAAM,EAAO,GAC5B,MAAM,EAAE,CAEV"}

package/src/builders/build/get-externals.js

@@ -0,0 +1,19 @@
+import { DEFAULT_ANGULAR_SHARED } from '../../index.js';
+/**
+ * MF equivalent of NF's `getExternals` (host path, M1.5): the packages the
+ * Angular app build must mark `external` so they resolve from the shared scope
+ * (es-module-shims import map, finding #6) instead of being bundled. For a pure
+ * host this is exactly the shared singleton set.
+ *
+ * Mirrors NF's trivial `[...Object.keys(shared), ...sharedMappings, ...externals]`,
+ * MF-shaped: the keys of the MF `shared` map (+ any extra explicit externals).
+ *
+ * ⚠️ The builder call-site swap (replacing `getExternals(normalized.config)` at
+ * `builder.ts:297`) is performed in **M2.1**, not here: that line and
+ * `buildForFederation` (`builder.ts:425`) consume the *same* `normalized.config`,
+ * so the externals source and the side-build's `shared` must switch to MF
+ * together — otherwise the host externalizes deps nothing provides.
+ */
+export function getHostExternals(shared = DEFAULT_ANGULAR_SHARED, extraExternals = []) {
+    return [...new Set([...Object.keys(shared), ...extraExternals])];
+}

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

@@ -0,0 +1,21 @@
+import type { BuilderContext } from '@angular-devkit/architect';
+import type { FederationInfo } from '@softarc/native-federation';
+type LocaleTranslation = string | string[];
+type LocaleObject = {
+    translation: LocaleTranslation;
+    baseHref?: string;
+    subPath?: string;
+};
+export type I18nConfig = {
+    sourceLocale: string | SourceLocaleObject;
+    locales: Record<string, LocaleTranslation | LocaleObject>;
+};
+type SourceLocaleObject = {
+    code: string;
+    baseHref?: string;
+    subPath?: string;
+};
+export declare function getI18nConfig(context: BuilderContext): Promise<I18nConfig | undefined>;
+export declare function translateFederationArtifacts(i18n: I18nConfig, localize: boolean | string[], outputPath: string, federationResult: FederationInfo): Promise<void>;
+export {};
+//# sourceMappingURL=i18n.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/i18n.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAKhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAMjE,KAAK,iBAAiB,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAE3C,KAAK,YAAY,GAAG;IAClB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,YAAY,EAAE,MAAM,GAAG,kBAAkB,CAAC;IAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,YAAY,CAAC,CAAC;CAC3D,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAO5F;AAED,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,OAAO,GAAG,MAAM,EAAE,EAC5B,UAAU,EAAE,MAAM,EAClB,gBAAgB,EAAE,cAAc,iBAiDjC"}

package/src/builders/build/i18n.js

@@ -0,0 +1,73 @@
+import { logger } from '@softarc/native-federation/internal';
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+export async function getI18nConfig(context) {
+    const workspaceConfig = (await context.getProjectMetadata(context.target?.project || ''));
+    const i18nConfig = workspaceConfig?.i18n;
+    return i18nConfig;
+}
+export async function translateFederationArtifacts(i18n, localize, outputPath, federationResult) {
+    const neededLocales = Array.isArray(localize) ? localize : Object.keys(i18n.locales);
+    const locales = Object.keys(i18n.locales).filter(locale => neededLocales.includes(locale));
+    if (locales.length === 0) {
+        return;
+    }
+    logger.info('Writing Translations');
+    const translationFiles = locales
+        .map(loc => i18n.locales[loc])
+        .map(config => typeof config === 'string' || Array.isArray(config) ? config : config.translation)
+        .map(files => JSON.stringify(files))
+        .join(' ');
+    const targetLocales = locales.join(' ');
+    const sourceLocale = typeof i18n.sourceLocale === 'string' ? i18n.sourceLocale : i18n.sourceLocale.code;
+    const translationOutPath = path.join(outputPath, 'browser', '{{LOCALE}}');
+    const federationFiles = [
+        ...federationResult.shared.map(s => s.outFileName),
+        ...federationResult.exposes.map(e => e.outFileName),
+        ...Object.values(federationResult.chunks ?? {}).flat(),
+    ];
+    // Here, we use a glob with an exhaustive list i/o `"*.js"`
+    // to improve performance
+    const sourcePattern = '{' + federationFiles.join(',') + '}';
+    const sourceLocalePath = path.join(outputPath, 'browser', sourceLocale);
+    const localizeTranslate = path.resolve('node_modules/.bin/localize-translate');
+    const cmd = `"${localizeTranslate}" -r "${sourceLocalePath}" -s "${sourcePattern}" -t ${translationFiles} -o "${translationOutPath}" --target-locales ${targetLocales} -l ${sourceLocale}`;
+    ensureDistFolders(locales, outputPath);
+    copyFederationArtifacts(locales, outputPath, sourceLocalePath);
+    logger.debug('Running: ' + cmd);
+    execCommand(cmd, 'Successfully translated');
+}
+function execCommand(cmd, defaultSuccessInfo) {
+    try {
+        const output = execSync(cmd);
+        logger.info(output.toString() || defaultSuccessInfo);
+    }
+    catch (error) {
+        logger.error(error.message);
+    }
+}
+/**
+ * Federation artifacts copied from the source locale into each target locale dir.
+ * M4.2: NF copied only `remoteEntry.json`; under MF the artifacts are the ESM
+ * container `remoteEntry.js` and the `mf-manifest.json` (both per-locale).
+ */
+const FEDERATION_ARTIFACTS = ['remoteEntry.js', 'mf-manifest.json'];
+function copyFederationArtifacts(locales, outputPath, sourceLocalePath) {
+    for (const artifact of FEDERATION_ARTIFACTS) {
+        const src = path.join(sourceLocalePath, artifact);
+        // A pure host has no `remoteEntry.js`; only copy artifacts that exist.
+        if (!fs.existsSync(src))
+            continue;
+        for (const locale of locales) {
+            const dest = path.join(outputPath, 'browser', locale, artifact);
+            fs.copyFileSync(src, dest);
+        }
+    }
+}
+function ensureDistFolders(locales, outputPath) {
+    for (const locale of locales) {
+        const localePath = path.join(outputPath, 'browser', locale);
+        fs.mkdirSync(localePath, { recursive: true });
+    }
+}

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

@@ -0,0 +1,35 @@
+import type { JsonObject } from "@angular-devkit/core";
+import type { BuildNotificationOptions } from "@softarc/native-federation";
+import type { ESMSInitOptions } from "es-module-shims";
+import type { Plugin } from "esbuild";
+
+export interface NfBuilderSchema extends JsonObject {
+  target: string;
+  dev: boolean;
+  port: number;
+  rebuildDelay: number;
+  buildNotifications?: BuildNotificationOptions;
+  federationConfigPath?: string;
+  watch?: boolean;
+  skipHtmlTransform: boolean;
+  esmsInitOptions: ESMSInitOptions;
+  baseHref?: string;
+  outputPath?: string;
+  projectName?: string;
+  ssr: boolean;
+  tsConfig?: string;
+  devServer?: boolean;
+  entryPoints?: string[];
+  cacheExternalArtifacts?: boolean;
+}
+
+export type NfInternalOptions = {
+  plugins?: Plugin[];
+
+  /**
+   * Enables instrumentation to collect code coverage data for specific files.
+   *
+   * Used exclusively for tests and shouldn't be used for other kinds of builds.
+   */
+  instrumentForCoverage?: (filename: string) => boolean;
+};

package/src/builders/build/schema.json

@@ -0,0 +1,93 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "native federation browser builder",
+  "description": "builder for native federation browser apps",
+  "type": "object",
+  "properties": {
+    "target": {
+      "type": "string",
+      "description": "target configured for the esbuild builder"
+    },
+    "dev": {
+      "type": "boolean",
+      "description": "Set this to true to start the builder in dev mode",
+      "default": false
+    },
+    "watch": {
+      "type": "boolean"
+    },
+    "port": {
+      "type": "number",
+      "default": 0
+    },
+    "entryPoints": {
+      "type": "array"
+    },
+    "rebuildDelay": {
+      "type": "number",
+      "default": 2000,
+      "description": "The delay for rebuilding federation artifacts. This allows to have more resources for refreshing your micro frontend in the browser."
+    },
+    "skipHtmlTransform": {
+      "type": "boolean",
+      "default": false
+    },
+    "baseHref": {
+      "type": "string"
+    },
+    "projectName": {
+      "type": "string"
+    },
+    "outputPath": {
+      "type": "string"
+    },
+    "esmsInitOptions": {
+      "type": "object",
+      "description": "Options for esms-module-shims https://github.com/guybedford/es-module-shims?tab=readme-ov-file#init-options",
+      "default": {
+        "shimMode": true
+      }
+    },
+    "ssr": {
+      "type": "boolean",
+      "description": "uses federation for ssr in ApplicationBuilder too",
+      "default": false
+    },
+    "devServer": {
+      "type": "boolean",
+      "description": "can be used to disable the dev server when dev=true"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "A specific tsconfig file for the nf remotes and exposed modules."
+    },
+    "cacheExternalArtifacts": {
+      "type": "boolean",
+      "default": true,
+      "description": "Will cache the shared externals so they can be re-used between builds",
+      "alias": "cache"
+    },
+    "buildNotifications": {
+      "type": "object",
+      "properties": {
+        "enable": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable build completion notifications for local development. It will send events to notify when the federation build is complete."
+        },
+        "endpoint": {
+          "type": "string",
+          "default": "/@angular-architects/native-federation:build-notifications",
+          "description": "You can override the default endpoint to send build completion events to."
+        }
+      }
+    },
+    "federationConfigPath": {
+      "type": "string",
+      "description": "The path to the federation config file. If not provided, the default path will be used.",
+      "default": "federation.config.mjs"
+    }
+  }
+}

package/src/builders/build/setup-builder-env-variables.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=setup-builder-env-variables.d.ts.map

package/src/builders/build/setup-builder-env-variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-builder-env-variables.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/setup-builder-env-variables.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Disables Angular's parallel caching and allows for
+ * a shared cache between the compilation steps which
+ * improves performance dramatically.
+ */
+if (!process.env['NG_BUILD_PARALLEL_TS']) {
+    process.env['NG_BUILD_PARALLEL_TS'] = '0';
+}

package/src/builders/build/update-index-html.d.ts

@@ -0,0 +1,5 @@
+import type { FederationOptions } from "@softarc/native-federation";
+import type { NfBuilderSchema } from "./schema.js";
+export declare function updateIndexHtml(fedOptions: FederationOptions, nfOptions: NfBuilderSchema): void;
+export declare function updateScriptTags(indexContent: string, nfOptions: NfBuilderSchema): string;
+//# sourceMappingURL=update-index-html.d.ts.map

package/src/builders/build/update-index-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-index-html.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/update-index-html.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAgB,eAAe,CAC7B,UAAU,EAAE,iBAAiB,EAC7B,SAAS,EAAE,eAAe,QAsB3B;AAED,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,eAAe,UA6B3B"}

package/src/builders/build/update-index-html.js

@@ -0,0 +1,33 @@
+import * as path from "path";
+import * as fs from "fs";
+export function updateIndexHtml(fedOptions, nfOptions) {
+    const outputPath = path.join(fedOptions.workspaceRoot, fedOptions.outputPath);
+    const indexPathCands = [
+        path.join(outputPath, "../server/index.server.html"),
+        path.join(outputPath, "index.html"),
+    ];
+    const indexPath = indexPathCands.find((c) => fs.existsSync(c));
+    if (!indexPath) {
+        console.error("No index.html found! Searched locations: ", indexPathCands.join(", "));
+        return;
+    }
+    let indexContent = fs.readFileSync(indexPath, "utf-8");
+    indexContent = updateScriptTags(indexContent, nfOptions);
+    fs.writeFileSync(indexPath, indexContent, "utf-8");
+}
+export function updateScriptTags(indexContent, nfOptions) {
+    const esmsOptions = {
+        shimMode: true,
+        ...nfOptions.esmsInitOptions,
+    };
+    const mainScriptType = esmsOptions.shimMode === false ? "module" : "module-shim";
+    const htmlFragment = `<script type="esms-options">${JSON.stringify(esmsOptions)}</script>`;
+    indexContent = indexContent.replace(/<script\b(?=[^>]*\bsrc="[^"]*polyfills[^"]*")[^>]*>/, (tag) => /\btype\s*=/.test(tag)
+        ? tag.replace(/\btype\s*=\s*"[^"]*"/, 'type="module"')
+        : tag.replace(/<script\b/, '<script type="module"'));
+    indexContent = indexContent.replace(/<script\b(?=[^>]*\bsrc="[^"]*main[^"]*")[^>]*>/, (tag) => /\btype\s*=/.test(tag)
+        ? tag.replace(/\btype\s*=\s*"[^"]*"/, `type="${mainScriptType}"`)
+        : tag.replace(/<script\b/, `<script type="${mainScriptType}"`));
+    indexContent = indexContent.replace(/(<body.*?>)/, `$1\n\t\t${htmlFragment}`);
+    return indexContent;
+}

package/src/builders/remote/assets.d.ts

@@ -0,0 +1,14 @@
+import type { ApplicationBuilderOptions } from '@angular/build';
+export type NormalizedAssetEntry = {
+    glob: string;
+    input: string;
+    output: string;
+    ignore?: string[];
+    followSymlinks?: boolean;
+    flatten?: boolean;
+};
+export declare function normalizeRemoteAssetEntries(assets: ApplicationBuilderOptions['assets'] | undefined, workspaceRoot: string, projectRoot: string, projectSourceRoot: string | undefined): NormalizedAssetEntry[];
+export declare function copyAllAssets(entries: NormalizedAssetEntry[], outputDir: string, workspaceRoot: string): Promise<void>;
+export declare function copyChangedAssets(entries: NormalizedAssetEntry[], outputDir: string, workspaceRoot: string, changedFiles: Iterable<string>): Promise<void>;
+export declare function getAssetWatchDirs(entries: NormalizedAssetEntry[], workspaceRoot: string): string[];
+//# sourceMappingURL=assets.d.ts.map

package/src/builders/remote/assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../../../src/builders/remote/assets.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAAG,SAAS,EACvD,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,iBAAiB,EAAE,MAAM,GAAG,SAAS,GACpC,oBAAoB,EAAE,CASxB;AA6BD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,oBAAoB,EAAE,EAC/B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,oBAAoB,EAAE,EAC/B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,oBAAoB,EAAE,EAC/B,aAAa,EAAE,MAAM,GACpB,MAAM,EAAE,CAEV"}

package/src/builders/remote/assets.js

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+import * as path from 'path';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - not re-exported from package root
+import { normalizeAssetPatterns } from '@angular/build/src/utils/normalize-asset-patterns.js';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore - not re-exported from package root
+import { resolveAssets } from '@angular/build/src/utils/resolve-assets.js';
+export function normalizeRemoteAssetEntries(assets, workspaceRoot, projectRoot, projectSourceRoot) {
+    if (!assets || assets.length === 0)
+        return [];
+    return normalizeAssetPatterns(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    assets, workspaceRoot, projectRoot, projectSourceRoot);
+}
+async function writeAssets(entries, outputDir, workspaceRoot, changed) {
+    if (entries.length === 0)
+        return;
+    const resolved = (await resolveAssets(entries, workspaceRoot));
+    const createdDirs = new Set();
+    for (const { source, destination } of resolved) {
+        if (changed && !changed.has(source))
+            continue;
+        const dest = path.join(outputDir, destination);
+        const dir = path.dirname(dest);
+        if (!createdDirs.has(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+            createdDirs.add(dir);
+        }
+        fs.copyFileSync(source, dest, fs.constants.COPYFILE_FICLONE);
+    }
+}
+export function copyAllAssets(entries, outputDir, workspaceRoot) {
+    return writeAssets(entries, outputDir, workspaceRoot);
+}
+export function copyChangedAssets(entries, outputDir, workspaceRoot, changedFiles) {
+    if (entries.length === 0)
+        return Promise.resolve();
+    const changed = new Set();
+    for (const file of changedFiles) {
+        changed.add(path.isAbsolute(file) ? file : path.resolve(workspaceRoot, file));
+    }
+    if (changed.size === 0)
+        return Promise.resolve();
+    return writeAssets(entries, outputDir, workspaceRoot, changed);
+}
+export function getAssetWatchDirs(entries, workspaceRoot) {
+    return entries.map(entry => path.resolve(workspaceRoot, entry.input));
+}

package/src/builders/remote/builder.d.ts

@@ -0,0 +1,13 @@
+import '../build/setup-builder-env-variables.js';
+import { type BuilderContext, type BuilderOutput } from '@angular-devkit/architect';
+import type { NfRemoteBuilderSchema, NfRemoteInternalOptions } from './schema.js';
+/**
+ * THIS BUILDER IS EXPERIMENTAL AND MIGHT CHANGE OVER TIME
+ *
+ * @param nfBuilderOptions
+ * @param context
+ */
+export declare function runRemoteBuilder(nfBuilderOptions: NfRemoteBuilderSchema & NfRemoteInternalOptions, context: BuilderContext): AsyncIterable<BuilderOutput>;
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=builder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../../src/builders/remote/builder.ts"],"names":[],"mappings":"AAAA,OAAO,yCAAyC,CAAC;AAOjD,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAiB,MAAM,2BAA2B,CAAC;AAmBnG,OAAO,KAAK,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAWlF;;;;;GAKG;AAEH,wBAAuB,gBAAgB,CACrC,gBAAgB,EAAE,qBAAqB,GAAG,uBAAuB,EACjE,OAAO,EAAE,cAAc,GACtB,aAAa,CAAC,aAAa,CAAC,CAmL9B;wBAGiD,GAAG;AAArD,wBAAsD"}

package/src/builders/remote/builder.js

@@ -0,0 +1,153 @@
+import '../build/setup-builder-env-variables.js';
+import * as path from 'path';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { SourceFileCache } from '@angular/build/private';
+import { createBuilder } from '@angular-devkit/architect';
+import { getExternals, normalizeFederationOptions, createFederationCache, } from '@softarc/native-federation';
+import { logger, setLogLevel, RebuildQueue, AbortedError, getDefaultCachePath, syncNfFileWatcher, } from '@softarc/native-federation/internal';
+import { createMfFederationBuilder } from '../../tools/mf/build-for-federation.js';
+import { checkForInvalidImports } from '../../utils/check-for-invalid-imports.js';
+import { resolveNgBuilderOptions } from './resolve-ng-options.js';
+import { inferFederationConfigPath } from './infer-config-path.js';
+import { createDebouncedChangeWatcher } from './change-watcher.js';
+import { copyAllAssets, copyChangedAssets, getAssetWatchDirs, normalizeRemoteAssetEntries, } from './assets.js';
+/**
+ * THIS BUILDER IS EXPERIMENTAL AND MIGHT CHANGE OVER TIME
+ *
+ * @param nfBuilderOptions
+ * @param context
+ */
+export async function* runRemoteBuilder(nfBuilderOptions, context) {
+    const federationTsConfig = nfBuilderOptions.tsConfig;
+    const outputBase = nfBuilderOptions.outputPath ?? `dist/${context.target.project}`;
+    const browserOutputPath = path.join(outputBase, 'browser');
+    const absoluteBrowserOutput = path.resolve(context.workspaceRoot, browserOutputPath);
+    const { ngBuilderOptions, projectRoot, projectSourceRoot } = await resolveNgBuilderOptions(nfBuilderOptions, context);
+    setLogLevel(nfBuilderOptions.verbose ? 'verbose' : 'info');
+    // Unlike the regular build builder, remote never bundles a main.ts / polyfills.
+    // Entry points come from the schema override or, when omitted, from the
+    // `exposes` map in federation.config.{mjs,js} (resolved by normalizeFederationOptions).
+    const entryPoints = nfBuilderOptions.entryPoints?.length
+        ? nfBuilderOptions.entryPoints
+        : undefined;
+    const cachePath = getDefaultCachePath(context.workspaceRoot);
+    const normalized = await normalizeFederationOptions({
+        projectName: nfBuilderOptions.projectName,
+        workspaceRoot: context.workspaceRoot,
+        outputPath: browserOutputPath,
+        federationConfig: inferFederationConfigPath(federationTsConfig, context.workspaceRoot),
+        tsConfig: federationTsConfig,
+        verbose: nfBuilderOptions.verbose,
+        watch: nfBuilderOptions.watch,
+        dev: !!nfBuilderOptions.dev,
+        entryPoints,
+        cacheExternalArtifacts: nfBuilderOptions.cacheExternalArtifacts !== false,
+    }, createFederationCache(cachePath, new SourceFileCache(cachePath)));
+    checkForInvalidImports(Object.values(normalized.config.sharedMappings), 'shared mappings');
+    checkForInvalidImports(Object.keys(normalized.config.shared), 'externals');
+    const start = process.hrtime();
+    logger.measure(start, 'To load the federation config.');
+    const externals = getExternals(normalized.config);
+    // MF side builder (M2.1) — replaces NF's adapter + buildForFederation/rebuildForFederation.
+    // Holds one esbuild context (Angular compiler + moduleFederationPlugin) for build + rebuilds.
+    const mfBuilder = await createMfFederationBuilder(normalized.config, normalized.options, externals, { builderOptions: ngBuilderOptions, context });
+    const assetEntries = normalizeRemoteAssetEntries(nfBuilderOptions.assets, context.workspaceRoot, projectRoot, projectSourceRoot);
+    const changeWatcher = nfBuilderOptions.watch
+        ? createDebouncedChangeWatcher(nfBuilderOptions.rebuildDelay)
+        : undefined;
+    if (changeWatcher) {
+        changeWatcher.watcher.addPaths(path.dirname(path.resolve(context.workspaceRoot, federationTsConfig)));
+        for (const assetDir of getAssetWatchDirs(assetEntries, context.workspaceRoot)) {
+            changeWatcher.watcher.addPaths(assetDir);
+        }
+    }
+    if (existsSync(normalized.options.outputPath)) {
+        rmSync(normalized.options.outputPath, { recursive: true });
+    }
+    mkdirSync(normalized.options.outputPath, { recursive: true });
+    try {
+        await mfBuilder.build();
+    }
+    catch (e) {
+        logger.error(e?.message ?? 'Building the artifacts failed');
+        process.exit(1);
+    }
+    await copyAllAssets(assetEntries, absoluteBrowserOutput, context.workspaceRoot);
+    if (changeWatcher) {
+        syncNfFileWatcher(changeWatcher.watcher, normalized.options.federationCache.bundlerCache);
+    }
+    const rebuildQueue = new RebuildQueue();
+    try {
+        yield { success: true };
+        while (nfBuilderOptions.watch && changeWatcher) {
+            await changeWatcher.waitForChange();
+            changeWatcher.resetChangePromise();
+            // fs.watch fires multiple events per save (write+rename, plus overlapping
+            // directory and per-file watchers). Redundant events arriving during a
+            // rebuild resolve the next promise, so without this guard the loop runs a
+            // second phantom build with an empty snapshot once the first one finishes.
+            if (changeWatcher.pendingPaths.size === 0)
+                continue;
+            // The freshly-reset change promise doubles as the interrupt signal: if a
+            // newer (debounced) change lands while this rebuild is in flight, abort it
+            // and loop to fold the new paths in — mirroring how the `build` builder
+            // passes Angular's next output as the interrupt to RebuildQueue.track.
+            // Without this, RebuildQueue's AbortSignal is never triggered and a stale
+            // rebuild must finish before a fresh save is picked up.
+            const interruptPromise = changeWatcher.waitForChange();
+            const trackResult = await rebuildQueue.track(async (signal) => {
+                try {
+                    if (signal?.aborted) {
+                        throw new AbortedError('Build canceled before starting');
+                    }
+                    // Snapshot but don't clear — unlike the build builder (which clears its
+                    // buffer eagerly and relies on Angular's iterator to re-trigger), this
+                    // builder owns its watcher, so if the build is aborted or fails the paths
+                    // stay in pendingPaths and are retried on the next cycle.
+                    const changedFiles = [...changeWatcher.pendingPaths];
+                    // NF's rebuild took an AbortSignal for mid-build cancellation; the MF
+                    // builder reuses its esbuild context (fast incremental rebuild), and the
+                    // RebuildQueue still wraps it with `signal` for queue-level interruption.
+                    await mfBuilder.rebuild(changedFiles);
+                    await copyChangedAssets(assetEntries, absoluteBrowserOutput, context.workspaceRoot, changedFiles);
+                    // Clear only what we consumed. Any paths pushed during the build
+                    // remain in pendingPaths and will drive the next iteration.
+                    for (const p of changedFiles)
+                        changeWatcher.pendingPaths.delete(p);
+                    syncNfFileWatcher(changeWatcher.watcher, normalized.options.federationCache.bundlerCache);
+                    if (signal?.aborted) {
+                        throw new AbortedError('[remote-builder] After federation build.');
+                    }
+                    logger.info('Done!');
+                    return { success: true };
+                }
+                catch (error) {
+                    if (error instanceof AbortedError) {
+                        logger.verbose('Rebuild was canceled. Cancellation point: ' + error?.message);
+                        return { success: false, cancelled: true };
+                    }
+                    logger.error('Federation rebuild failed!');
+                    if (nfBuilderOptions.verbose)
+                        console.error(error);
+                    return { success: false };
+                }
+            }, interruptPromise);
+            // Mirrors the build builder's trackResult handling, minus the iterator pump:
+            // there the 'interrupted' branch feeds Angular's next output back into the
+            // loop, whereas here the new change has already resolved the current change
+            // promise, so the next loop iteration picks it up immediately. The aborted
+            // build left its paths in pendingPaths, so nothing is lost.
+            if (trackResult.type === 'completed' && !trackResult.result.cancelled) {
+                yield { success: trackResult.result.success };
+            }
+        }
+    }
+    finally {
+        changeWatcher?.dispose();
+        rebuildQueue.dispose();
+        await mfBuilder.dispose();
+        await changeWatcher?.watcher.close();
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default createBuilder(runRemoteBuilder);

package/src/builders/remote/change-watcher.d.ts

@@ -0,0 +1,10 @@
+import { type NfFileWatcher } from '@softarc/native-federation/internal';
+export interface DebouncedChangeWatcher {
+    watcher: NfFileWatcher;
+    pendingPaths: Set<string>;
+    waitForChange: () => Promise<void>;
+    resetChangePromise: () => void;
+    dispose: () => void;
+}
+export declare function createDebouncedChangeWatcher(rebuildDelay: number): DebouncedChangeWatcher;
+//# sourceMappingURL=change-watcher.d.ts.map

package/src/builders/remote/change-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change-watcher.d.ts","sourceRoot":"","sources":["../../../../src/builders/remote/change-watcher.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAE1F,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;IACvB,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,aAAa,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,4BAA4B,CAAC,YAAY,EAAE,MAAM,GAAG,sBAAsB,CAoCzF"}

package/src/builders/remote/change-watcher.js

@@ -0,0 +1,35 @@
+import { createNfWatcher } from '@softarc/native-federation/internal';
+export function createDebouncedChangeWatcher(rebuildDelay) {
+    const pendingPaths = new Set();
+    let notifyChange = () => { };
+    let changePromise = new Promise(r => (notifyChange = r));
+    const resetChangePromise = () => {
+        changePromise = new Promise(r => (notifyChange = r));
+    };
+    const debounceMs = Math.max(10, rebuildDelay);
+    let debounceTimer;
+    const scheduleNotify = () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            debounceTimer = undefined;
+            notifyChange();
+        }, debounceMs);
+    };
+    const watcher = createNfWatcher({
+        onChange: p => {
+            pendingPaths.add(p);
+            scheduleNotify();
+        },
+    });
+    return {
+        watcher,
+        pendingPaths,
+        waitForChange: () => changePromise,
+        resetChangePromise,
+        dispose: () => {
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+        },
+    };
+}

package/src/builders/remote/infer-config-path.d.ts

@@ -0,0 +1,2 @@
+export declare function inferFederationConfigPath(tsConfig: string, workspaceRoot: string): string;
+//# sourceMappingURL=infer-config-path.d.ts.map

package/src/builders/remote/infer-config-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer-config-path.d.ts","sourceRoot":"","sources":["../../../../src/builders/remote/infer-config-path.ts"],"names":[],"mappings":"AAGA,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASzF"}

package/src/builders/remote/infer-config-path.js

@@ -0,0 +1,10 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function inferFederationConfigPath(tsConfig, workspaceRoot) {
+    const relProjectPath = path.dirname(tsConfig);
+    const mjsRelPath = path.join(relProjectPath, 'federation.config.mjs');
+    if (fs.existsSync(path.resolve(workspaceRoot, mjsRelPath))) {
+        return mjsRelPath;
+    }
+    return path.join(relProjectPath, 'federation.config.js');
+}