@nx/angular 0.0.0-pr-22179-271588f

package/src/builders/dev-server/lib/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./validate-options"), exports);

package/src/builders/dev-server/lib/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(schema: Schema): NormalizedSchema;

package/src/builders/dev-server/lib/normalize-options.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+function normalizeOptions(schema) {
+    let buildTarget = schema.buildTarget;
+    if (schema.browserTarget) {
+        buildTarget ??= schema.browserTarget;
+        delete schema.browserTarget;
+    }
+    return {
+        ...schema,
+        buildTarget,
+        host: schema.host ?? 'localhost',
+        port: schema.port ?? 4200,
+        liveReload: schema.liveReload ?? true,
+        open: schema.open ?? false,
+        ssl: schema.ssl ?? false,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/builders/dev-server/lib/validate-options.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../schema';
+export declare function validateOptions(options: Schema): void;

package/src/builders/dev-server/lib/validate-options.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const angular_version_utils_1 = require("../../../executors/utilities/angular-version-utils");
+function validateOptions(options) {
+    const { major: angularMajorVersion, version: angularVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if ((0, semver_1.lt)(angularVersion, '16.1.0') && options.forceEsbuild !== undefined) {
+        throw new Error((0, devkit_1.stripIndents) `The "forceEsbuild" option is only supported in Angular >= 16.1.0. You are currently using "${angularVersion}".
+      You can resolve this error by removing the "forceEsbuild" option or by migrating to Angular 16.1.0.`);
+    }
+    if (angularMajorVersion < 17 && options.esbuildMiddleware?.length > 0) {
+        throw new Error((0, devkit_1.stripIndents) `The "esbuildMiddleware" option is only supported in Angular >= 17.0.0. You are currently using "${angularVersion}".
+      You can resolve this error by removing the "esbuildMiddleware" option or by migrating to Angular 17.0.0.`);
+    }
+    if ((0, semver_1.lt)(angularVersion, '17.2.0') && options.prebundle) {
+        throw new Error((0, devkit_1.stripIndents) `The "prebundle" option is only supported in Angular >= 17.2.0. You are currently using "${angularVersion}".
+      You can resolve this error by removing the "prebundle" option or by migrating to Angular 17.2.0.`);
+    }
+}
+exports.validateOptions = validateOptions;

package/src/builders/dev-server/schema.d.ts

@@ -0,0 +1,39 @@
+interface BaseSchema {
+  port?: number;
+  host?: string;
+  proxyConfig?: string;
+  ssl?: boolean;
+  sslKey?: string;
+  sslCert?: string;
+  headers?: Record<string, string>;
+  open?: boolean;
+  verbose?: boolean;
+  liveReload?: boolean;
+  publicHost?: string;
+  allowedHosts?: string[];
+  servePath?: string;
+  disableHostCheck?: boolean;
+  hmr?: boolean;
+  watch?: boolean;
+  poll?: number;
+  forceEsbuild?: boolean;
+  prebundle?: boolean | { exclude: string[] };
+  buildLibsFromSource?: boolean;
+  esbuildMiddleware?: string[];
+}
+
+export type SchemaWithBrowserTarget = BaseSchema & {
+  browserTarget: string;
+};
+
+export type SchemaWithBuildTarget = BaseSchema & {
+  buildTarget: string;
+};
+
+export type Schema = SchemaWithBrowserTarget | SchemaWithBuildTarget;
+
+export type NormalizedSchema = SchemaWithBuildTarget & {
+  liveReload: boolean;
+  open: boolean;
+  ssl: boolean;
+};

package/src/builders/dev-server/schema.json

@@ -0,0 +1,153 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Schema for Webpack Dev Server",
+  "description": "Serves an Angular application using [Webpack](https://webpack.js.org/) when the build target is using a Webpack-based executor, or [Vite](https://vitejs.dev/) when the build target uses an esbuild-based executor.",
+  "examplesFile": "../../../docs/dev-server-examples.md",
+  "type": "object",
+  "presets": [
+    {
+      "name": "Using a Different Port",
+      "keys": ["buildTarget", "port"]
+    }
+  ],
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "A browser builder target to serve in the format of `project:target[:configuration]`. Ignored if `buildTarget` is set.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$",
+      "x-deprecated": "Use 'buildTarget' instead. It will be removed in Nx v19."
+    },
+    "buildTarget": {
+      "type": "string",
+      "description": "A build builder target to serve in the format of `project:target[:configuration]`.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "port": {
+      "type": "number",
+      "description": "Port to listen on.",
+      "default": 4200
+    },
+    "host": {
+      "type": "string",
+      "description": "Host to listen on.",
+      "default": "localhost"
+    },
+    "proxyConfig": {
+      "type": "string",
+      "description": "Proxy configuration file. For more information, see https://angular.io/guide/build#proxying-to-a-backend-server."
+    },
+    "ssl": {
+      "type": "boolean",
+      "description": "Serve using HTTPS.",
+      "default": false
+    },
+    "sslKey": {
+      "type": "string",
+      "description": "SSL key to use for serving HTTPS."
+    },
+    "sslCert": {
+      "type": "string",
+      "description": "SSL certificate to use for serving HTTPS."
+    },
+    "headers": {
+      "type": "object",
+      "description": "Custom HTTP headers to be added to all responses.",
+      "propertyNames": {
+        "pattern": "^[-_A-Za-z0-9]+$"
+      },
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "open": {
+      "type": "boolean",
+      "description": "Opens the url in default browser.",
+      "default": false,
+      "alias": "o"
+    },
+    "verbose": {
+      "type": "boolean",
+      "description": "Adds more details to output logging."
+    },
+    "liveReload": {
+      "type": "boolean",
+      "description": "Whether to reload the page on change, using live-reload.",
+      "default": true
+    },
+    "publicHost": {
+      "type": "string",
+      "description": "The URL that the browser client (or live-reload client, if enabled) should use to connect to the development server. Use for a complex dev server setup, such as one with reverse proxies."
+    },
+    "allowedHosts": {
+      "type": "array",
+      "description": "List of hosts that are allowed to access the dev server.",
+      "default": [],
+      "items": {
+        "type": "string"
+      }
+    },
+    "servePath": {
+      "type": "string",
+      "description": "The pathname where the app will be served."
+    },
+    "disableHostCheck": {
+      "type": "boolean",
+      "description": "Don't verify connected clients are part of allowed hosts.",
+      "default": false
+    },
+    "hmr": {
+      "type": "boolean",
+      "description": "Enable hot module replacement.",
+      "default": false
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Rebuild on change.",
+      "default": true
+    },
+    "poll": {
+      "type": "number",
+      "description": "Enable and define the file watching poll time period in milliseconds."
+    },
+    "forceEsbuild": {
+      "type": "boolean",
+      "description": "Force the development server to use the 'browser-esbuild' builder when building. This is a developer preview option for the esbuild-based build system. _Note: this is only supported in Angular versions >= 16.1.0_.",
+      "default": false
+    },
+    "prebundle": {
+      "description": "Enable and control the Vite-based development server's prebundling capabilities. To enable prebundling, the Angular CLI cache must also be enabled. This option has no effect when using the 'browser' or other Webpack-based builders. _Note: this is only supported in Angular versions >= 17.2.0_.",
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "object",
+          "properties": {
+            "exclude": {
+              "description": "List of package imports that should not be prebundled by the development server. The packages will be bundled into the application code itself.",
+              "type": "array",
+              "items": { "type": "string" }
+            }
+          },
+          "additionalProperties": false,
+          "required": ["exclude"]
+        }
+      ]
+    },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source instead of building them separately. If not set, it will take the value specified in the `browserTarget` options, or it will default to `true` if it's also not set in the `browserTarget` options.",
+      "x-priority": "important"
+    },
+    "esbuildMiddleware": {
+      "description": "A list of HTTP request middleware functions. _Note: this is only supported in Angular versions >= 17.0.0_.",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "description": "The path to the middleware function. Relative to the workspace root."
+      }
+    }
+  },
+  "additionalProperties": false,
+  "anyOf": [{ "required": ["buildTarget"] }, { "required": ["browserTarget"] }]
+}

package/src/builders/module-federation-dev-ssr/module-federation-dev-ssr.impl.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from './schema';
+export declare function executeModuleFederationDevSSRBuilder(schema: Schema, context: import('@angular-devkit/architect').BuilderContext): import("rxjs").Observable<unknown>;
+declare const _default: any;
+export default _default;

package/src/builders/module-federation-dev-ssr/module-federation-dev-ssr.impl.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeModuleFederationDevSSRBuilder = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const executor_utils_1 = require("nx/src/command-line/run/executor-utils");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const angular_version_utils_1 = require("../../executors/utilities/angular-version-utils");
+const module_federation_1 = require("../utilities/module-federation");
+function executeModuleFederationDevSSRBuilder(schema, context) {
+    const { ...options } = schema;
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const { projects: workspaceProjects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const project = workspaceProjects[context.target.project];
+    let pathToManifestFile = (0, path_1.join)(context.workspaceRoot, project.sourceRoot, 'assets/module-federation.manifest.json');
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.workspaceRoot, options.pathToManifestFile);
+        if (!(0, fs_1.existsSync)(userPathToManifestFile)) {
+            throw new Error(`The provided Module Federation manifest file path does not exist. Please check the file exists at "${userPathToManifestFile}".`);
+        }
+        else if ((0, path_1.extname)(options.pathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    (0, module_federation_1.validateDevRemotes)(options, workspaceProjects);
+    const remotesToSkip = new Set(options.skipRemotes ?? []);
+    const staticRemotes = (0, module_federation_1.getStaticRemotes)(project, context, workspaceProjects, remotesToSkip);
+    const dynamicRemotes = (0, module_federation_1.getDynamicRemotes)(project, context, workspaceProjects, remotesToSkip, pathToManifestFile);
+    const remotes = [...staticRemotes, ...dynamicRemotes];
+    const devServeRemotes = !options.devRemotes
+        ? []
+        : Array.isArray(options.devRemotes)
+            ? options.devRemotes
+            : [options.devRemotes];
+    const remoteProcessPromises = [];
+    for (const remote of remotes) {
+        const isDev = devServeRemotes.includes(remote);
+        const target = isDev ? 'serve-ssr' : 'static-server';
+        if (!workspaceProjects[remote].targets?.[target]) {
+            throw new Error(`Could not find "${target}" target in "${remote}" project.`);
+        }
+        else if (!workspaceProjects[remote].targets?.[target].executor) {
+            throw new Error(`Could not find executor for "${target}" target in "${remote}" project.`);
+        }
+        const runOptions = {};
+        if (options.verbose) {
+            const [collection, executor] = workspaceProjects[remote].targets[target].executor.split(':');
+            const { schema } = (0, executor_utils_1.getExecutorInformation)(collection, executor, devkit_1.workspaceRoot, workspaceProjects);
+            if (schema.additionalProperties || 'verbose' in schema.properties) {
+                runOptions.verbose = options.verbose;
+            }
+        }
+        const remotePromise = new Promise((res, rej) => {
+            if (target === 'static-server') {
+                const remoteProject = workspaceProjects[remote];
+                const remoteServerOutput = (0, path_1.join)(devkit_1.workspaceRoot, remoteProject.targets.server.options.outputPath, 'main.js');
+                const pm = (0, devkit_1.getPackageManagerCommand)();
+                (0, child_process_1.execSync)(`${pm.exec} nx run ${remote}:server${context.target.configuration
+                    ? `:${context.target.configuration}`
+                    : ''}`, { stdio: 'inherit' });
+                const child = (0, child_process_1.fork)(remoteServerOutput, {
+                    env: { PORT: remoteProject.targets['serve-ssr'].options.port },
+                });
+                child.on('message', (msg) => {
+                    if (msg === 'nx.server.ready') {
+                        res();
+                    }
+                });
+            }
+            if (target === 'serve-ssr') {
+                (0, ngcli_adapter_1.scheduleTarget)(context.workspaceRoot, {
+                    project: remote,
+                    target,
+                    configuration: context.target.configuration,
+                    runOptions,
+                    projects: workspaceProjects,
+                }, options.verbose).then((obs) => obs
+                    .pipe((0, operators_1.tap)((result) => {
+                    result.success && res();
+                }))
+                    .toPromise());
+            }
+        });
+        remoteProcessPromises.push(remotePromise);
+    }
+    const { major: angularMajorVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    const { executeSSRDevServerBuilder } = angularMajorVersion >= 17
+        ? require('@angular-devkit/build-angular')
+        : require('@nguniversal/builders');
+    return (0, rxjs_1.from)(Promise.all(remoteProcessPromises)).pipe((0, operators_1.switchMap)(() => executeSSRDevServerBuilder(options, context)));
+}
+exports.executeModuleFederationDevSSRBuilder = executeModuleFederationDevSSRBuilder;
+exports.default = require('@angular-devkit/architect').createBuilder(executeModuleFederationDevSSRBuilder);

package/src/builders/module-federation-dev-ssr/schema.d.ts

@@ -0,0 +1,17 @@
+export interface Schema {
+  browserTarget: string;
+  serverTarget: string;
+  host?: string;
+  port?: number;
+  progress: boolean;
+  open?: boolean;
+  publicHost?: string;
+  ssl?: boolean;
+  sslKey?: string;
+  sslCert?: string;
+  proxyConfig?: string;
+  devRemotes?: string[];
+  skipRemotes?: string[];
+  verbose: boolean;
+  pathToManifestFile?: string;
+}

package/src/builders/module-federation-dev-ssr/schema.json

@@ -0,0 +1,90 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Module Federation SSR Dev Server Target",
+  "description": "SSR Dev Server target options for Module Federation host applications.",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Browser target to build.",
+      "pattern": ".+:.+(:.+)?"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Server target to build.",
+      "pattern": ".+:.+(:.+)?"
+    },
+    "host": {
+      "type": "string",
+      "description": "Host to listen on.",
+      "default": "localhost"
+    },
+    "port": {
+      "type": "number",
+      "default": 4200,
+      "description": "Port to start the development server at. Default is 4200. Pass 0 to get a dynamically assigned port."
+    },
+    "publicHost": {
+      "type": "string",
+      "description": "The URL that the browser client should use to connect to the development server. Use for a complex dev server setup, such as one with reverse proxies."
+    },
+    "open": {
+      "type": "boolean",
+      "description": "Opens the url in default browser.",
+      "default": false,
+      "alias": "o"
+    },
+    "progress": {
+      "type": "boolean",
+      "description": "Log progress to the console while building."
+    },
+    "inspect": {
+      "type": "boolean",
+      "description": "Launch the development server in inspector mode and listen on address and port '127.0.0.1:9229'.",
+      "default": false
+    },
+    "ssl": {
+      "type": "boolean",
+      "description": "Serve using HTTPS.",
+      "default": false
+    },
+    "sslKey": {
+      "type": "string",
+      "description": "SSL key to use for serving HTTPS."
+    },
+    "sslCert": {
+      "type": "string",
+      "description": "SSL certificate to use for serving HTTPS."
+    },
+    "proxyConfig": {
+      "type": "string",
+      "description": "Proxy configuration file."
+    },
+    "devRemotes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of remote applications to run in development mode (i.e. using serve target).",
+      "x-priority": "important"
+    },
+    "skipRemotes": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "List of remote applications to not automatically serve, either statically or in development mode."
+    },
+    "verbose": {
+      "type": "boolean",
+      "description": "Adds more details to output logging.",
+      "default": false
+    },
+    "pathToManifestFile": {
+      "type": "string",
+      "description": "Path to a Module Federation manifest file (e.g. `my/path/to/module-federation.manifest.json`) containing the dynamic remote applications relative to the workspace root."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["browserTarget", "serverTarget"]
+}

package/src/builders/utilities/buildable-libs.d.ts

@@ -0,0 +1,9 @@
+import { DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+import { ProjectGraph } from '@nx/devkit';
+export declare function createTmpTsConfigForBuildableLibs(tsConfigPath: string, context: import('@angular-devkit/architect').BuilderContext, options?: {
+    projectGraph?: ProjectGraph;
+    target?: string;
+}): {
+    tsConfigPath: string;
+    dependencies: DependentBuildableProjectNode[];
+};

package/src/builders/utilities/buildable-libs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTmpTsConfigForBuildableLibs = void 0;
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function createTmpTsConfigForBuildableLibs(tsConfigPath, context, options) {
+    let dependencies;
+    const result = (0, buildable_libs_utils_1.calculateProjectDependencies)(options?.projectGraph ?? (0, devkit_1.readCachedProjectGraph)(), context.workspaceRoot, context.target.project, options?.target ?? context.target.target, context.target.configuration);
+    dependencies = result.dependencies;
+    const tmpTsConfigPath = (0, buildable_libs_utils_1.createTmpTsConfig)((0, path_1.join)(context.workspaceRoot, tsConfigPath), context.workspaceRoot, result.target.data.root, dependencies);
+    process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
+    return { tsConfigPath: tmpTsConfigPath, dependencies };
+}
+exports.createTmpTsConfigForBuildableLibs = createTmpTsConfigForBuildableLibs;

package/src/builders/utilities/module-federation.d.ts

@@ -0,0 +1,6 @@
+import { ProjectConfiguration } from '@nx/devkit';
+export declare function getDynamicRemotes(project: ProjectConfiguration, context: import('@angular-devkit/architect').BuilderContext, workspaceProjects: Record<string, ProjectConfiguration>, remotesToSkip: Set<string>, pathToManifestFile?: string): string[];
+export declare function getStaticRemotes(project: ProjectConfiguration, context: import('@angular-devkit/architect').BuilderContext, workspaceProjects: Record<string, ProjectConfiguration>, remotesToSkip: Set<string>): string[];
+export declare function validateDevRemotes(options: {
+    devRemotes?: string[];
+}, workspaceProjects: Record<string, ProjectConfiguration>): void;

package/src/builders/utilities/module-federation.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDevRemotes = exports.getStaticRemotes = exports.getDynamicRemotes = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/src/internal");
+function getDynamicRemotes(project, context, workspaceProjects, remotesToSkip, pathToManifestFile = (0, path_1.join)(context.workspaceRoot, project.sourceRoot, 'assets/module-federation.manifest.json')) {
+    // check for dynamic remotes
+    // we should only check for dynamic based on what we generate
+    // and fallback to empty array
+    if (!(0, fs_1.existsSync)(pathToManifestFile)) {
+        return [];
+    }
+    const moduleFederationManifestJson = (0, fs_1.readFileSync)(pathToManifestFile, 'utf-8');
+    if (!moduleFederationManifestJson) {
+        return [];
+    }
+    // This should have shape of
+    // {
+    //   "remoteName": "remoteLocation",
+    // }
+    const parsedManifest = JSON.parse(moduleFederationManifestJson);
+    if (!Object.keys(parsedManifest).every((key) => typeof key === 'string' && typeof parsedManifest[key] === 'string')) {
+        return [];
+    }
+    const allDynamicRemotes = Object.entries(parsedManifest)
+        .map(([remoteName]) => remoteName)
+        .filter((r) => !remotesToSkip.has(r));
+    const remotesNotInWorkspace = [];
+    const dynamicRemotes = allDynamicRemotes.filter((remote) => {
+        if (!workspaceProjects[remote]) {
+            remotesNotInWorkspace.push(remote);
+            return false;
+        }
+        return true;
+    });
+    if (remotesNotInWorkspace.length > 0) {
+        devkit_1.logger.warn(`Skipping serving ${remotesNotInWorkspace.join(', ')} as they could not be found in the workspace. Ensure they are served correctly.`);
+    }
+    return dynamicRemotes;
+}
+exports.getDynamicRemotes = getDynamicRemotes;
+function getModuleFederationConfig(tsconfigPath, workspaceRoot, projectRoot) {
+    const moduleFederationConfigPathJS = (0, path_1.join)(workspaceRoot, projectRoot, 'module-federation.config.js');
+    const moduleFederationConfigPathTS = (0, path_1.join)(workspaceRoot, projectRoot, 'module-federation.config.ts');
+    let moduleFederationConfigPath = moduleFederationConfigPathJS;
+    let cleanupTranspiler = () => { };
+    if ((0, fs_1.existsSync)(moduleFederationConfigPathTS)) {
+        cleanupTranspiler = (0, internal_1.registerTsProject)((0, path_1.join)(workspaceRoot, tsconfigPath));
+        moduleFederationConfigPath = moduleFederationConfigPathTS;
+    }
+    try {
+        const config = require(moduleFederationConfigPath);
+        cleanupTranspiler();
+        return {
+            mfeConfig: config.default || config,
+            mfConfigPath: moduleFederationConfigPath,
+        };
+    }
+    catch {
+        throw new Error(`Could not load ${moduleFederationConfigPath}. Was this project generated with "@nx/angular:host"?`);
+    }
+}
+function getStaticRemotes(project, context, workspaceProjects, remotesToSkip) {
+    const { mfeConfig, mfConfigPath } = getModuleFederationConfig(project.targets.build.options.tsConfig, context.workspaceRoot, project.root);
+    const remotesConfig = Array.isArray(mfeConfig.remotes) && mfeConfig.remotes.length > 0
+        ? mfeConfig.remotes
+        : [];
+    const allStaticRemotes = remotesConfig
+        .map((remoteDefinition) => Array.isArray(remoteDefinition) ? remoteDefinition[0] : remoteDefinition)
+        .filter((r) => !remotesToSkip.has(r));
+    const remotesNotInWorkspace = [];
+    const staticRemotes = allStaticRemotes.filter((remote) => {
+        if (!workspaceProjects[remote]) {
+            remotesNotInWorkspace.push(remote);
+            return false;
+        }
+        return true;
+    });
+    if (remotesNotInWorkspace.length > 0) {
+        devkit_1.logger.warn(`Skipping serving ${remotesNotInWorkspace.join(', ')} as they could not be found in the workspace. Ensure they are served correctly.`);
+    }
+    return staticRemotes;
+}
+exports.getStaticRemotes = getStaticRemotes;
+function validateDevRemotes(options, workspaceProjects) {
+    const invalidDevRemotes = options.devRemotes?.filter((remote) => !workspaceProjects[remote]) ?? [];
+    if (invalidDevRemotes.length) {
+        throw new Error(invalidDevRemotes.length === 1
+            ? `Invalid dev remote provided: ${invalidDevRemotes[0]}.`
+            : `Invalid dev remotes provided: ${invalidDevRemotes.join(', ')}.`);
+    }
+}
+exports.validateDevRemotes = validateDevRemotes;

package/src/builders/utilities/webpack.d.ts

@@ -0,0 +1,6 @@
+export declare function mergeCustomWebpackConfig(baseWebpackConfig: any, pathToWebpackConfig: string, options: {
+    tsConfig: string;
+    [k: string]: any;
+}, target: import('@angular-devkit/architect').Target): Promise<any>;
+export declare function resolveCustomWebpackConfig(path: string, tsConfig: string): any;
+export declare function resolveIndexHtmlTransformer(path: string, tsConfig: string, target: import('@angular-devkit/architect').Target): (indexHtml: any) => any;

package/src/builders/utilities/webpack.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIndexHtmlTransformer = exports.resolveCustomWebpackConfig = exports.mergeCustomWebpackConfig = void 0;
+const webpack_merge_1 = require("webpack-merge");
+const internal_1 = require("@nx/js/src/internal");
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+async function mergeCustomWebpackConfig(baseWebpackConfig, pathToWebpackConfig, options, target) {
+    const customWebpackConfiguration = resolveCustomWebpackConfig(pathToWebpackConfig, options.tsConfig.startsWith(devkit_1.workspaceRoot)
+        ? options.tsConfig
+        : (0, path_1.join)(devkit_1.workspaceRoot, options.tsConfig));
+    // The extra Webpack configuration file can also export a Promise, for instance:
+    // `module.exports = new Promise(...)`. If it exports a single object, but not a Promise,
+    // then await will just resolve that object.
+    const config = await customWebpackConfiguration;
+    // The extra Webpack configuration file can export a synchronous or asynchronous function,
+    // for instance: `module.exports = async config => { ... }`.
+    if (typeof config === 'function') {
+        return config(baseWebpackConfig, options, target);
+    }
+    else {
+        return (0, webpack_merge_1.merge)(baseWebpackConfig, config);
+    }
+}
+exports.mergeCustomWebpackConfig = mergeCustomWebpackConfig;
+function resolveCustomWebpackConfig(path, tsConfig) {
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    const customWebpackConfig = require(path);
+    cleanupTranspiler();
+    // If the user provides a configuration in TS file
+    // then there are 2 cases for exporting an object. The first one is:
+    // `module.exports = { ... }`. And the second one is:
+    // `export default { ... }`. The ESM format is compiled into:
+    // `{ default: { ... } }`
+    return customWebpackConfig.default ?? customWebpackConfig;
+}
+exports.resolveCustomWebpackConfig = resolveCustomWebpackConfig;
+function resolveIndexHtmlTransformer(path, tsConfig, target) {
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    const indexTransformer = require(path);
+    cleanupTranspiler();
+    const transform = indexTransformer.default ?? indexTransformer;
+    return (indexHtml) => transform(target, indexHtml);
+}
+exports.resolveIndexHtmlTransformer = resolveIndexHtmlTransformer;