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

package/src/executors/delegate-build/delegate-build.impl.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { DelegateBuildExecutorSchema } from './schema';
+export declare function delegateBuildExecutor(options: DelegateBuildExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+}, {
+    success: boolean;
+}, undefined>;
+export default delegateBuildExecutor;

package/src/executors/delegate-build/delegate-build.impl.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delegateBuildExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+async function* delegateBuildExecutor(options, context) {
+    const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
+    options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)((0, devkit_1.joinPathFragments)(context.root, options.tsConfig), context.root, target.data.root, dependencies);
+    if (!(0, buildable_libs_utils_1.checkDependentProjectsHaveBeenBuilt)(context.root, context.projectName, context.targetName, dependencies)) {
+        return { success: false };
+    }
+    const { buildTarget, ...targetOptions } = options;
+    const delegateTarget = (0, devkit_1.parseTargetString)(buildTarget, context);
+    yield* await (0, devkit_1.runExecutor)(delegateTarget, targetOptions, context);
+}
+exports.delegateBuildExecutor = delegateBuildExecutor;
+exports.default = delegateBuildExecutor;

package/src/executors/delegate-build/schema.d.ts

@@ -0,0 +1,6 @@
+export interface DelegateBuildExecutorSchema {
+  buildTarget: string;
+  outputPath: string;
+  tsConfig: string;
+  watch?: boolean;
+}

package/src/executors/delegate-build/schema.json

@@ -0,0 +1,34 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Schema for an executor which delegates a build.",
+  "description": "Delegates the build to a different target while supporting incremental builds.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "buildTarget": {
+      "description": "Build target used for building the application after its dependencies have been built.",
+      "type": "string"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "The full path for the output directory, relative to the workspace root.",
+      "x-completion-type": "directory"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The full path for the TypeScript configuration file, relative to the workspace root.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json"
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Whether to run a build when any file changes.",
+      "default": false
+    }
+  },
+  "additionalProperties": false,
+  "required": ["buildTarget", "outputPath", "tsConfig"],
+  "examplesFile": "../../../docs/delegate-build-examples.md"
+}

package/src/executors/extract-i18n/extract-i18n.impl.d.ts

@@ -0,0 +1,3 @@
+import { type ExecutorContext } from '@nx/devkit';
+import type { ExtractI18nExecutorOptions } from './schema';
+export default function extractI18nExecutor(options: ExtractI18nExecutorOptions, context: ExecutorContext): AsyncGenerator<never, import("@angular-devkit/architect").BuilderOutput, unknown>;

package/src/executors/extract-i18n/extract-i18n.impl.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const angular_version_utils_1 = require("../utilities/angular-version-utils");
+const patch_builder_context_1 = require("../utilities/patch-builder-context");
+async function* extractI18nExecutor(options, context) {
+    const parsedBuildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+    const browserTargetProjectConfiguration = (0, project_graph_1.readCachedProjectConfiguration)(parsedBuildTarget.project);
+    const buildTarget = browserTargetProjectConfiguration.targets[parsedBuildTarget.target];
+    const isUsingEsbuildBuilder = [
+        '@angular-devkit/build-angular:application',
+        '@angular-devkit/build-angular:browser-esbuild',
+        '@nx/angular:application',
+        '@nx/angular:browser-esbuild',
+    ].includes(buildTarget.executor);
+    const builderContext = await (0, ngcli_adapter_1.createBuilderContext)({
+        builderName: 'extrct-i18n',
+        description: 'Extracts i18n messages from source code.',
+        optionSchema: await Promise.resolve().then(() => require('./schema.json')),
+    }, context);
+    /**
+     * The Angular CLI extract-i18n builder make some decisions based on the build
+     * target builder but it only considers `@angular-devkit/build-angular:*`
+     * builders. Since we are using a custom builder, we patch the context to
+     * handle `@nx/angular:*` executors.
+     */
+    (0, patch_builder_context_1.patchBuilderContext)(builderContext, isUsingEsbuildBuilder, parsedBuildTarget);
+    const { executeExtractI18nBuilder } = await Promise.resolve().then(() => require('@angular-devkit/build-angular'));
+    const delegateBuilderOptions = getDelegateBuilderOptions(options);
+    return await executeExtractI18nBuilder(delegateBuilderOptions, builderContext);
+}
+exports.default = extractI18nExecutor;
+function getDelegateBuilderOptions(options) {
+    const delegateBuilderOptions = { ...options };
+    const { major: angularMajorVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if (angularMajorVersion <= 17) {
+        delegateBuilderOptions.browserTarget = delegateBuilderOptions.buildTarget;
+        delete delegateBuilderOptions.buildTarget;
+    }
+    return delegateBuilderOptions;
+}

package/src/executors/extract-i18n/schema.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractI18nBuilderOptions } from '@angular-devkit/build-angular';
+
+export type ExtractI18nExecutorOptions = Omit<
+  ExtractI18nBuilderOptions,
+  'browserTarget'
+> & {
+  buildTarget: string;
+};

package/src/executors/extract-i18n/schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema",
+  "title": "Schema for Nx extract-i18n Executor",
+  "description": "Extracts i18n messages from source code.",
+  "outputCapture": "direct-nodejs",
+  "type": "object",
+  "properties": {
+    "buildTarget": {
+      "type": "string",
+      "description": "A builder target to extract i18n messages in the format of `project:target[:configuration]`. You can also pass in more than one configuration name as a comma-separated list. Example: `project:target:production,staging`.",
+      "pattern": "^[^:\\s]+:[^:\\s]+(:[^\\s]+)?$"
+    },
+    "format": {
+      "type": "string",
+      "description": "Output format for the generated file.",
+      "default": "xlf",
+      "enum": [
+        "xmb",
+        "xlf",
+        "xlif",
+        "xliff",
+        "xlf2",
+        "xliff2",
+        "json",
+        "arb",
+        "legacy-migrate"
+      ]
+    },
+    "progress": {
+      "type": "boolean",
+      "description": "Log progress to the console.",
+      "default": true
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "Path where output will be placed."
+    },
+    "outFile": {
+      "type": "string",
+      "description": "Name of the file to output."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["buildTarget"]
+}

package/src/executors/module-federation-dev-server/lib/build-static-remotes.d.ts

@@ -0,0 +1,4 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext } from '@nx/devkit';
+import type { StaticRemotesConfig } from './parse-static-remotes-config';
+export declare function buildStaticRemotes(staticRemotesConfig: StaticRemotesConfig, nxBin: any, context: ExecutorContext, options: Schema): Promise<void>;

package/src/executors/module-federation-dev-server/lib/build-static-remotes.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStaticRemotes = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+async function buildStaticRemotes(staticRemotesConfig, nxBin, context, options) {
+    if (!staticRemotesConfig.remotes.length) {
+        return;
+    }
+    const mappedLocationOfRemotes = {};
+    for (const app of staticRemotesConfig.remotes) {
+        mappedLocationOfRemotes[app] = `http${options.ssl ? 's' : ''}://${options.host}:${options.staticRemotesPort}/${staticRemotesConfig.config[app].urlSegment}`;
+    }
+    process.env.NX_MF_DEV_SERVER_STATIC_REMOTES = JSON.stringify(mappedLocationOfRemotes);
+    await new Promise((res) => {
+        devkit_1.logger.info(`NX Building ${staticRemotesConfig.remotes.length} static remotes...`);
+        const staticProcess = (0, child_process_1.fork)(nxBin, [
+            'run-many',
+            `--target=build`,
+            `--projects=${staticRemotesConfig.remotes.join(',')}`,
+            ...(context.configurationName
+                ? [`--configuration=${context.configurationName}`]
+                : []),
+            ...(options.parallel ? [`--parallel=${options.parallel}`] : []),
+        ], {
+            cwd: context.root,
+            stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
+        });
+        staticProcess.stdout.on('data', (data) => {
+            const ANSII_CODE_REGEX = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+            const stdoutString = data.toString().replace(ANSII_CODE_REGEX, '');
+            if (stdoutString.includes('Successfully ran target build')) {
+                staticProcess.stdout.removeAllListeners('data');
+                devkit_1.logger.info(`NX Built ${staticRemotesConfig.remotes.length} static remotes`);
+                res();
+            }
+        });
+        staticProcess.stderr.on('data', (data) => devkit_1.logger.info(data.toString()));
+        staticProcess.on('exit', (code) => {
+            if (code !== 0) {
+                throw new Error(`Remotes failed to build. See above for errors.`);
+            }
+        });
+        process.on('SIGTERM', () => staticProcess.kill('SIGTERM'));
+        process.on('exit', () => staticProcess.kill('SIGTERM'));
+    });
+}
+exports.buildStaticRemotes = buildStaticRemotes;

package/src/executors/module-federation-dev-server/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './build-static-remotes';
+export * from './normalize-options';
+export * from './parse-static-remotes-config';
+export * from './start-dev-remotes';
+export * from './start-static-remotes-file-server';

package/src/executors/module-federation-dev-server/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./build-static-remotes"), exports);
+tslib_1.__exportStar(require("./normalize-options"), exports);
+tslib_1.__exportStar(require("./parse-static-remotes-config"), exports);
+tslib_1.__exportStar(require("./start-dev-remotes"), exports);
+tslib_1.__exportStar(require("./start-static-remotes-file-server"), exports);

package/src/executors/module-federation-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/executors/module-federation-dev-server/lib/normalize-options.js

@@ -0,0 +1,23 @@
+"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;
+    }
+    schema.buildLibsFromSource ??= true;
+    process.env.NX_BUILD_LIBS_FROM_SOURCE = `${schema.buildLibsFromSource}`;
+    process.env.NX_BUILD_TARGET = `${buildTarget}`;
+    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/executors/module-federation-dev-server/lib/parse-static-remotes-config.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutorContext } from '@nx/devkit';
+export type StaticRemoteConfig = {
+    basePath: string;
+    outputPath: string;
+    urlSegment: string;
+};
+export type StaticRemotesConfig = {
+    remotes: string[];
+    config: Record<string, StaticRemoteConfig> | undefined;
+};
+export declare function parseStaticRemotesConfig(staticRemotes: string[] | undefined, context: ExecutorContext): StaticRemotesConfig;

package/src/executors/module-federation-dev-server/lib/parse-static-remotes-config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStaticRemotesConfig = void 0;
+const path_1 = require("path");
+function parseStaticRemotesConfig(staticRemotes, context) {
+    if (!staticRemotes?.length) {
+        return { remotes: [], config: undefined };
+    }
+    const config = {};
+    for (const app of staticRemotes) {
+        const outputPath = context.projectGraph.nodes[app].data.targets['build'].options.outputPath;
+        const basePath = (0, path_1.dirname)(outputPath);
+        const urlSegment = (0, path_1.basename)(outputPath);
+        config[app] = { basePath, outputPath, urlSegment };
+    }
+    return { remotes: staticRemotes, config };
+}
+exports.parseStaticRemotesConfig = parseStaticRemotesConfig;

package/src/executors/module-federation-dev-server/lib/start-dev-remotes.d.ts

@@ -0,0 +1,9 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext, type ProjectConfiguration } from '@nx/devkit';
+export declare function startDevRemotes(remotes: {
+    remotePorts: any[];
+    staticRemotes: string[];
+    devRemotes: string[];
+}, workspaceProjects: Record<string, ProjectConfiguration>, options: Schema, context: ExecutorContext): Promise<AsyncIterable<{
+    success: boolean;
+}>[]>;

package/src/executors/module-federation-dev-server/lib/start-dev-remotes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevRemotes = void 0;
+const devkit_1 = require("@nx/devkit");
+async function startDevRemotes(remotes, workspaceProjects, options, context) {
+    const devRemotesIters = [];
+    for (const app of remotes.devRemotes) {
+        if (!workspaceProjects[app].targets?.['serve']) {
+            throw new Error(`Could not find "serve" target in "${app}" project.`);
+        }
+        else if (!workspaceProjects[app].targets?.['serve'].executor) {
+            throw new Error(`Could not find executor for "serve" target in "${app}" project.`);
+        }
+        const [collection, executor] = workspaceProjects[app].targets['serve'].executor.split(':');
+        const isUsingModuleFederationDevServerExecutor = executor.includes('module-federation-dev-server');
+        devRemotesIters.push(await (0, devkit_1.runExecutor)({
+            project: app,
+            target: 'serve',
+            configuration: context.configurationName,
+        }, {
+            verbose: options.verbose ?? false,
+            ...(isUsingModuleFederationDevServerExecutor
+                ? { isInitialHost: false }
+                : {}),
+        }, context));
+    }
+    return devRemotesIters;
+}
+exports.startDevRemotes = startDevRemotes;

package/src/executors/module-federation-dev-server/lib/start-static-remotes-file-server.d.ts

@@ -0,0 +1,9 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type Schema } from '../schema';
+import type { StaticRemotesConfig } from './parse-static-remotes-config';
+export declare function startStaticRemotesFileServer(staticRemotesConfig: StaticRemotesConfig, context: ExecutorContext, options: Schema): AsyncGenerator<{
+    success: boolean;
+    baseUrl: string;
+}, {
+    success: boolean;
+}, unknown>;

package/src/executors/module-federation-dev-server/lib/start-static-remotes-file-server.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startStaticRemotesFileServer = void 0;
+const devkit_1 = require("@nx/devkit");
+const file_server_impl_1 = require("@nx/web/src/executors/file-server/file-server.impl");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function startStaticRemotesFileServer(staticRemotesConfig, context, options) {
+    let shouldMoveToCommonLocation = false;
+    let commonOutputDirectory;
+    for (const app of staticRemotesConfig.remotes) {
+        const remoteBasePath = staticRemotesConfig.config[app].basePath;
+        if (!commonOutputDirectory) {
+            commonOutputDirectory = remoteBasePath;
+        }
+        else if (commonOutputDirectory !== remoteBasePath) {
+            shouldMoveToCommonLocation = true;
+            break;
+        }
+    }
+    if (shouldMoveToCommonLocation) {
+        commonOutputDirectory = (0, path_1.join)(devkit_1.workspaceRoot, 'tmp/static-remotes');
+        for (const app of staticRemotesConfig.remotes) {
+            const remoteConfig = staticRemotesConfig.config[app];
+            (0, fs_1.cpSync)(remoteConfig.outputPath, (0, path_1.join)(commonOutputDirectory, remoteConfig.urlSegment), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+    const staticRemotesIter = (0, file_server_impl_1.default)({
+        cors: true,
+        watch: false,
+        staticFilePath: commonOutputDirectory,
+        parallel: false,
+        spa: false,
+        withDeps: false,
+        host: options.host,
+        port: options.staticRemotesPort,
+        ssl: options.ssl,
+        sslCert: options.sslCert,
+        sslKey: options.sslKey,
+    }, context);
+    return staticRemotesIter;
+}
+exports.startStaticRemotesFileServer = startStaticRemotesFileServer;

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.d.ts

@@ -0,0 +1,4 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type Schema } from './schema';
+export declare function moduleFederationDevServerExecutor(schema: Schema, context: ExecutorContext): AsyncGenerator<any, any, undefined>;
+export default moduleFederationDevServerExecutor;

package/src/executors/module-federation-dev-server/module-federation-dev-server.impl.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleFederationDevServerExecutor = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+const rxjs_for_await_1 = require("@nx/devkit/src/utils/rxjs-for-await");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const module_federation_1 = require("@nx/webpack/src/utils/module-federation");
+const wait_for_port_open_1 = require("@nx/web/src/utils/wait-for-port-open");
+const file_server_impl_1 = require("@nx/web/src/executors/file-server/file-server.impl");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const dev_server_impl_1 = require("../../builders/dev-server/dev-server.impl");
+const module_federation_2 = require("../../builders/utilities/module-federation");
+const path_1 = require("path");
+const fs_1 = require("fs");
+async function* moduleFederationDevServerExecutor(schema, context) {
+    // Force Node to resolve to look for the nx binary that is inside node_modules
+    const nxBin = require.resolve('nx/bin/nx');
+    const options = (0, lib_1.normalizeOptions)(schema);
+    options.staticRemotesPort ??= options.port + 1;
+    const { projects: workspaceProjects } = (0, devkit_1.readProjectsConfigurationFromProjectGraph)(context.projectGraph);
+    const project = workspaceProjects[context.projectName];
+    const currIter = options.static
+        ? (0, file_server_impl_1.default)({
+            port: options.port,
+            host: options.host,
+            ssl: options.ssl,
+            buildTarget: options.buildTarget,
+            parallel: false,
+            spa: false,
+            withDeps: false,
+            cors: true,
+        }, context)
+        : (0, rxjs_for_await_1.eachValueFrom)((0, dev_server_impl_1.executeDevServerBuilder)(options, await (0, ngcli_adapter_1.createBuilderContext)({
+            builderName: '@nx/angular:webpack-browser',
+            description: 'Build a browser application',
+            optionSchema: await Promise.resolve().then(() => require('../../builders/webpack-browser/schema.json')),
+        }, context)));
+    if (options.isInitialHost === false) {
+        return yield* currIter;
+    }
+    let pathToManifestFile = (0, path_1.join)(context.root, project.sourceRoot, 'assets/module-federation.manifest.json');
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, 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_2.validateDevRemotes)(options, workspaceProjects);
+    const moduleFederationConfig = (0, module_federation_1.getModuleFederationConfig)(project.targets.build.options.tsConfig, context.root, project.root, 'angular');
+    const remotes = (0, module_federation_1.getRemotes)(options.devRemotes, options.skipRemotes, moduleFederationConfig, {
+        projectName: project.name,
+        projectGraph: context.projectGraph,
+        root: context.root,
+    }, pathToManifestFile);
+    if (remotes.devRemotes.length > 0 && !schema.staticRemotesPort) {
+        options.staticRemotesPort = options.devRemotes.reduce((portToUse, r) => {
+            const remotePort = context.projectGraph.nodes[r].data.targets['serve'].options.port;
+            if (remotePort >= portToUse) {
+                return remotePort + 1;
+            }
+            else {
+                return portToUse;
+            }
+        }, options.staticRemotesPort);
+    }
+    const staticRemotesConfig = (0, lib_1.parseStaticRemotesConfig)(remotes.staticRemotes, context);
+    await (0, lib_1.buildStaticRemotes)(staticRemotesConfig, nxBin, context, options);
+    const devRemoteIters = await (0, lib_1.startDevRemotes)(remotes, workspaceProjects, options, context);
+    const staticRemotesIter = remotes.staticRemotes.length > 0
+        ? (0, lib_1.startStaticRemotesFileServer)(staticRemotesConfig, context, options)
+        : undefined;
+    const removeBaseUrlEmission = (iter) => (0, async_iterable_1.mapAsyncIterable)(iter, (v) => ({
+        ...v,
+        baseUrl: undefined,
+    }));
+    return yield* (0, async_iterable_1.combineAsyncIterables)(removeBaseUrlEmission(currIter), ...devRemoteIters.map(removeBaseUrlEmission), ...(staticRemotesIter ? [removeBaseUrlEmission(staticRemotesIter)] : []), (0, async_iterable_1.createAsyncIterable)(async ({ next, done }) => {
+        if (!options.isInitialHost) {
+            done();
+            return;
+        }
+        if (remotes.remotePorts.length === 0) {
+            devkit_1.logger.info(`NX All remotes started, server ready at http://localhost:${options.port}`);
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+            done();
+            return;
+        }
+        try {
+            const portsToWaitFor = staticRemotesIter
+                ? [options.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, wait_for_port_open_1.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: 'localhost',
+            })));
+            devkit_1.logger.info(`NX All remotes started, server ready at http://localhost:${options.port}`);
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+        }
+        catch (err) {
+            throw new Error(`Failed to start remotes. Check above for any errors.`, {
+                cause: err,
+            });
+        }
+        finally {
+            done();
+        }
+    }));
+}
+exports.moduleFederationDevServerExecutor = moduleFederationDevServerExecutor;
+exports.default = moduleFederationDevServerExecutor;

package/src/executors/module-federation-dev-server/schema.d.ts

@@ -0,0 +1,43 @@
+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;
+  devRemotes?: string[];
+  skipRemotes?: string[];
+  pathToManifestFile?: string;
+  static?: boolean;
+  isInitialHost?: boolean;
+  parallel?: number;
+  staticRemotesPort?: number;
+  buildLibsFromSource?: boolean;
+}
+
+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;
+};