@nx/rspack 0.0.0-pr-28218-5048fd1

package/src/utils/generator-utils.js

@@ -0,0 +1,444 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExistingTargetsInProject = findExistingTargetsInProject;
+exports.addOrChangeBuildTarget = addOrChangeBuildTarget;
+exports.addOrChangeServeTarget = addOrChangeServeTarget;
+exports.writeRspackConfigFile = writeRspackConfigFile;
+exports.deleteWebpackConfig = deleteWebpackConfig;
+exports.moveAndEditIndexHtml = moveAndEditIndexHtml;
+exports.normalizeViteConfigFilePathWithTree = normalizeViteConfigFilePathWithTree;
+exports.getViteConfigPathForProject = getViteConfigPathForProject;
+exports.handleUnsupportedUserProvidedTargets = handleUnsupportedUserProvidedTargets;
+exports.handleUnknownExecutors = handleUnknownExecutors;
+exports.determineFrameworkAndTarget = determineFrameworkAndTarget;
+exports.determineMain = determineMain;
+exports.determineTsConfig = determineTsConfig;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+function findExistingTargetsInProject(targets, userProvidedTargets) {
+    const output = {
+        validFoundTargetName: {},
+        projectContainsUnsupportedExecutor: false,
+        userProvidedTargetIsUnsupported: {},
+        alreadyHasNxRspackTargets: {},
+    };
+    const supportedExecutors = {
+        build: [
+            '@nxext/vite:build',
+            '@nrwl/webpack:webpack',
+            '@nrwl/rollup:rollup',
+            '@nrwl/web:rollup',
+            '@nrwl/vite:build',
+            '@nx/webpack:webpack',
+            '@nx/rollup:rollup',
+            '@nx/web:rollup',
+            '@nx/vite:build',
+        ],
+        serve: [
+            '@nxext/vite:dev',
+            '@nrwl/webpack:dev-server',
+            '@nrwl/vite:dev-server',
+            '@nx/webpack:dev-server',
+            '@nx/vite:dev-server',
+        ],
+    };
+    const unsupportedExecutors = [
+        '@nx/js:babel',
+        '@nx/js:node',
+        '@nx/js:swc',
+        '@nx/react-native:run-ios',
+        '@nx/react-native:start',
+        '@nx/react-native:run-android',
+        '@nx/react-native:bundle',
+        '@nx/react-native:build-android',
+        '@nx/react-native:bundle',
+        '@nx/next:build',
+        '@nx/next:server',
+        '@nx/js:tsc',
+        '@nx/angular:ng-packagr-lite',
+        '@nx/angular:package',
+        '@nx/angular:webpack-browser',
+        '@nx/esbuild:esbuild',
+        '@nrwl/js:babel',
+        '@nrwl/js:node',
+        '@nrwl/js:swc',
+        '@nrwl/react-native:run-ios',
+        '@nrwl/react-native:start',
+        '@nrwl/react-native:run-android',
+        '@nrwl/react-native:bundle',
+        '@nrwl/react-native:build-android',
+        '@nrwl/react-native:bundle',
+        '@nrwl/next:build',
+        '@nrwl/next:server',
+        '@nrwl/js:tsc',
+        '@nrwl/angular:ng-packagr-lite',
+        '@nrwl/angular:package',
+        '@nrwl/angular:webpack-browser',
+        '@nrwl/esbuild:esbuild',
+        '@angular-devkit/build-angular:browser',
+        '@angular-devkit/build-angular:dev-server',
+    ];
+    // First, we check if the user has provided a target
+    // If they have, we check if the executor the target is using is supported
+    // If it's not supported, then we set the unsupported flag to true for that target
+    function checkUserProvidedTarget(target) {
+        if (userProvidedTargets?.[target]) {
+            if (supportedExecutors[target].includes(targets[userProvidedTargets[target]]?.executor)) {
+                output.validFoundTargetName[target] = userProvidedTargets[target];
+            }
+            else {
+                output.userProvidedTargetIsUnsupported[target] = true;
+            }
+        }
+    }
+    checkUserProvidedTarget('build');
+    checkUserProvidedTarget('serve');
+    // Returns early when we have a build, serve, and test targets.
+    if (output.validFoundTargetName.build && output.validFoundTargetName.serve) {
+        return output;
+    }
+    // We try to find the targets that are using the supported executors
+    // for build, serve and test, since these are the ones we will be converting
+    for (const target in targets) {
+        const executorName = targets[target].executor;
+        const hasRspackTargets = output.alreadyHasNxRspackTargets;
+        hasRspackTargets.build ||= executorName === '@nx/rspack:rspack';
+        hasRspackTargets.serve ||= executorName === '@nx/rspack:dev-server';
+        const foundTargets = output.validFoundTargetName;
+        if (!foundTargets.build &&
+            supportedExecutors.build.includes(executorName)) {
+            foundTargets.build = target;
+        }
+        if (!foundTargets.serve &&
+            supportedExecutors.serve.includes(executorName)) {
+            foundTargets.serve = target;
+        }
+        output.projectContainsUnsupportedExecutor ||=
+            unsupportedExecutors.includes(executorName);
+    }
+    return output;
+}
+function addOrChangeBuildTarget(tree, options, target) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const assets = [];
+    if (options.target === 'web' &&
+        tree.exists((0, devkit_1.joinPathFragments)(project.root, 'src/favicon.ico'))) {
+        assets.push((0, devkit_1.joinPathFragments)(project.root, 'src/favicon.ico'));
+    }
+    if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'src/assets'))) {
+        assets.push((0, devkit_1.joinPathFragments)(project.root, 'src/assets'));
+    }
+    const buildOptions = {
+        target: options.target ?? 'web',
+        outputPath: (0, devkit_1.joinPathFragments)('dist', 
+        // If standalone project then use the project's name in dist.
+        project.root === '.' ? project.name : project.root),
+        main: determineMain(tree, options),
+        tsConfig: determineTsConfig(tree, options),
+        rspackConfig: (0, devkit_1.joinPathFragments)(project.root, 'rspack.config.js'),
+        assets,
+    };
+    project.targets ??= {};
+    project.targets[target] = {
+        executor: '@nx/rspack:rspack',
+        outputs: ['{options.outputPath}'],
+        defaultConfiguration: 'production',
+        options: buildOptions,
+        configurations: {
+            development: {
+                mode: 'development',
+            },
+            production: {
+                mode: 'production',
+                optimization: options.target === 'web' ? true : undefined,
+                sourceMap: false,
+            },
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+}
+function addOrChangeServeTarget(tree, options, target) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    project.targets ??= {};
+    project.targets[target] = {
+        executor: '@nx/rspack:dev-server',
+        options: {
+            buildTarget: `${options.project}:build:development`,
+        },
+        configurations: {
+            development: {},
+            production: {
+                buildTarget: `${options.project}:build:production`,
+            },
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+}
+function writeRspackConfigFile(tree, options, stylePreprocessorOptions) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    tree.write((0, devkit_1.joinPathFragments)(project.root, 'rspack.config.js'), createConfig(options, stylePreprocessorOptions));
+}
+function createConfig(options, stylePreprocessorOptions) {
+    if (options.framework === 'react') {
+        return `
+      const { composePlugins, withNx, withReact } = require('@nx/rspack');
+
+      module.exports = composePlugins(withNx(), withReact(${stylePreprocessorOptions
+            ? `
+        {
+          stylePreprocessorOptions: ${JSON.stringify(stylePreprocessorOptions)},
+        }
+        `
+            : ''}), (config) => {
+        return config;
+      });
+    `;
+    }
+    else if (options.framework === 'web' || options.target === 'web') {
+        return `
+      const { composePlugins, withNx, withWeb } = require('@nx/rspack');
+
+      module.exports = composePlugins(withNx(), withWeb(${stylePreprocessorOptions
+            ? `
+        {
+          stylePreprocessorOptions: ${JSON.stringify(stylePreprocessorOptions)},
+        }
+        `
+            : ''}), (config) => {
+        return config;
+      });
+    `;
+    }
+    else if (options.framework === 'nest') {
+        return `
+    const { composePlugins, withNx } = require('@nx/rspack');
+
+    module.exports = composePlugins(withNx(), (config) => {
+      return config;
+    });
+    `;
+    }
+    else {
+        return `
+      const { composePlugins, withNx${stylePreprocessorOptions ? ', withWeb' : ''} } = require('@nx/rspack');
+
+      module.exports = composePlugins(withNx()${stylePreprocessorOptions
+            ? `,
+        withWeb({
+          stylePreprocessorOptions: ${JSON.stringify(stylePreprocessorOptions)},
+        })`
+            : ''}, (config) => {
+        return config;
+      });
+    `;
+    }
+}
+function deleteWebpackConfig(tree, projectRoot, webpackConfigFilePath) {
+    const webpackConfigPath = webpackConfigFilePath && tree.exists(webpackConfigFilePath)
+        ? webpackConfigFilePath
+        : tree.exists(`${projectRoot}/webpack.config.js`)
+            ? `${projectRoot}/webpack.config.js`
+            : tree.exists(`${projectRoot}/webpack.config.ts`)
+                ? `${projectRoot}/webpack.config.ts`
+                : null;
+    if (webpackConfigPath) {
+        tree.delete(webpackConfigPath);
+    }
+}
+// Maybe add delete vite config?
+function moveAndEditIndexHtml(tree, options, buildTarget) {
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    let indexHtmlPath = projectConfig.targets?.[buildTarget]?.options?.index ??
+        `${projectConfig.root}/src/index.html`;
+    let mainPath = projectConfig.targets?.[buildTarget]?.options?.main ??
+        `${projectConfig.root}/src/main.ts${options.framework === 'react' ? 'x' : ''}`;
+    if (projectConfig.root !== '.') {
+        mainPath = mainPath.replace(projectConfig.root, '');
+    }
+    if (!tree.exists(indexHtmlPath) &&
+        tree.exists(`${projectConfig.root}/index.html`)) {
+        indexHtmlPath = `${projectConfig.root}/index.html`;
+    }
+    if (tree.exists(indexHtmlPath)) {
+        const indexHtmlContent = tree.read(indexHtmlPath, 'utf8');
+        if (!indexHtmlContent.includes(`<script type="module" src="${mainPath}"></script>`)) {
+            tree.write(`${projectConfig.root}/index.html`, indexHtmlContent.replace('</body>', `<script type="module" src="${mainPath}"></script>
+          </body>`));
+            if (tree.exists(`${projectConfig.root}/src/index.html`)) {
+                tree.delete(`${projectConfig.root}/src/index.html`);
+            }
+        }
+    }
+    else {
+        tree.write(`${projectConfig.root}/index.html`, `<!DOCTYPE html>
+      <html lang="en">
+        <head>
+          <meta charset="UTF-8" />
+          <link rel="icon" href="/favicon.ico" />
+          <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+          <title>Vite</title>
+        </head>
+        <body>
+          <div id="root"></div>
+          <script type="module" src="${mainPath}"></script>
+        </body>
+      </html>`);
+    }
+}
+function normalizeViteConfigFilePathWithTree(tree, projectRoot, configFile) {
+    return configFile && tree.exists(configFile)
+        ? configFile
+        : tree.exists((0, devkit_1.joinPathFragments)(`${projectRoot}/rspack.config.ts`))
+            ? (0, devkit_1.joinPathFragments)(`${projectRoot}/rspack.config.ts`)
+            : tree.exists((0, devkit_1.joinPathFragments)(`${projectRoot}/rspack.config.js`))
+                ? (0, devkit_1.joinPathFragments)(`${projectRoot}/rspack.config.js`)
+                : undefined;
+}
+function getViteConfigPathForProject(tree, projectName, target) {
+    let viteConfigPath;
+    const { targets, root } = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    if (target) {
+        viteConfigPath = targets?.[target]?.options?.configFile;
+    }
+    else {
+        const config = Object.values(targets).find((config) => config.executor === '@nx/rspack:build');
+        viteConfigPath = config?.options?.configFile;
+    }
+    return normalizeViteConfigFilePathWithTree(tree, root, viteConfigPath);
+}
+async function handleUnsupportedUserProvidedTargets(userProvidedTargetIsUnsupported, userProvidedTargetName, validFoundTargetName, framework) {
+    if (userProvidedTargetIsUnsupported.build && validFoundTargetName.build) {
+        await handleUnsupportedUserProvidedTargetsErrors(userProvidedTargetName.build, validFoundTargetName.build, 'build', 'rspack');
+    }
+    if (framework !== 'nest' &&
+        userProvidedTargetIsUnsupported.serve &&
+        validFoundTargetName.serve) {
+        await handleUnsupportedUserProvidedTargetsErrors(userProvidedTargetName.serve, validFoundTargetName.serve, 'serve', 'dev-server');
+    }
+}
+async function handleUnsupportedUserProvidedTargetsErrors(userProvidedTargetName, validFoundTargetName, target, executor) {
+    devkit_1.logger.warn(`The custom ${target} target you provided (${userProvidedTargetName}) cannot be converted to use the @nx/rspack:${executor} executor.
+     However, we found the following ${target} target in your project that can be converted: ${validFoundTargetName}
+
+     Please note that converting a potentially non-compatible project to use Vite.js may result in unexpected behavior. Always commit
+     your changes before converting a project to use Vite.js, and test the converted project thoroughly before deploying it.
+    `);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Confirm } = require('enquirer');
+    const prompt = new Confirm({
+        name: 'question',
+        message: `Should we convert the ${validFoundTargetName} target to use the @nx/rspack:${executor} executor?`,
+        initial: true,
+    });
+    const shouldConvert = await prompt.run();
+    if (!shouldConvert) {
+        throw new Error(`The ${target} target ${userProvidedTargetName} cannot be converted to use the @nx/rspack:${executor} executor.
+      Please try again, either by providing a different ${target} target or by not providing a target at all (Nx will
+        convert the first one it finds, most probably this one: ${validFoundTargetName})
+
+      Please note that converting a potentially non-compatible project to use Vite.js may result in unexpected behavior. Always commit
+      your changes before converting a project to use Vite.js, and test the converted project thoroughly before deploying it.
+      `);
+    }
+}
+async function handleUnknownExecutors(projectName) {
+    devkit_1.logger.warn(`
+      We could not find any targets in project ${projectName} that use executors which
+      can be converted to the @nx/rspack executors.
+
+      This either means that your project may not have a target
+      for building, serving, or testing at all, or that your targets are
+      using executors that are not known to Nx.
+
+      If you still want to convert your project to use the @nx/rspack executors,
+      please make sure to commit your changes before running this generator.
+      `);
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { Confirm } = require('enquirer');
+    const prompt = new Confirm({
+        name: 'question',
+        message: `Should Nx convert your project to use the @nx/rspack executors?`,
+        initial: true,
+    });
+    const shouldConvert = await prompt.run();
+    if (!shouldConvert) {
+        throw new Error(`
+      Nx could not verify that the executors you are using can be converted to the @nx/rspack executors.
+      Please try again with a different project.
+    `);
+    }
+}
+function determineFrameworkAndTarget(tree, options, projectRoot, targets) {
+    (0, ensure_typescript_1.ensureTypescript)();
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    // First try to infer if the target is node
+    if (options.target !== 'node') {
+        // Try to infer from jest config if the env is node
+        let jestConfigPath;
+        if (targets?.test?.executor !== '@nx/jest:jest' &&
+            targets?.test?.options?.jestConfig) {
+            jestConfigPath = targets?.test?.options?.jestConfig;
+        }
+        else {
+            jestConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'jest.config.ts');
+        }
+        if (!tree.exists(jestConfigPath)) {
+            return { target: options.target, framework: options.framework };
+        }
+        const appFileContent = tree.read(jestConfigPath, 'utf-8');
+        const file = tsquery.ast(appFileContent);
+        // find testEnvironment: 'node' in jest config
+        const testEnvironment = tsquery(file, `PropertyAssignment:has(Identifier[name="testEnvironment"]) > StringLiteral[value="node"]`);
+        if (testEnvironment.length > 0) {
+            return { target: 'node', framework: options.framework };
+        }
+        if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'src/main.ts'))) {
+            const appFileContent = tree.read((0, devkit_1.joinPathFragments)(projectRoot, 'src/main.ts'), 'utf-8');
+            const file = tsquery.ast(appFileContent);
+            const hasNestJsDependency = tsquery(file, `ImportDeclaration:has(StringLiteral[value="@nestjs/common"])`);
+            if (hasNestJsDependency?.length > 0) {
+                return { target: 'node', framework: 'nest' };
+            }
+        }
+    }
+    if (options.framework === 'nest') {
+        return { target: 'node', framework: 'nest' };
+    }
+    if (options.framework !== 'react' && options.target === 'web') {
+        // Look if React is used in the project
+        let tsConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json');
+        if (!tree.exists(tsConfigPath)) {
+            tsConfigPath = determineTsConfig(tree, options);
+        }
+        const tsConfig = JSON.parse(tree.read(tsConfigPath).toString());
+        if (tsConfig?.compilerOptions?.jsx?.includes('react')) {
+            return { target: 'web', framework: 'react' };
+        }
+        else {
+            return { target: options.target, framework: options.framework };
+        }
+    }
+    return { target: options.target, framework: options.framework };
+}
+function determineMain(tree, options) {
+    if (options.main)
+        return options.main;
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const mainTsx = (0, devkit_1.joinPathFragments)(project.root, 'src/main.tsx');
+    if (tree.exists(mainTsx))
+        return mainTsx;
+    return (0, devkit_1.joinPathFragments)(project.root, 'src/main.ts');
+}
+function determineTsConfig(tree, options) {
+    if (options.tsConfig)
+        return options.tsConfig;
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const appJson = (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.app.json');
+    if (tree.exists(appJson))
+        return appJson;
+    const libJson = (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.lib.json');
+    if (tree.exists(libJson))
+        return libJson;
+    return (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.json');
+}

package/src/utils/get-copy-patterns.d.ts

@@ -0,0 +1,9 @@
+export declare function getCopyPatterns(assets: any[]): {
+    context: any;
+    to: any;
+    from: any;
+    globOptions: {
+        ignore: any[];
+        dot: boolean;
+    };
+}[];

package/src/utils/get-copy-patterns.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCopyPatterns = getCopyPatterns;
+function getCopyPatterns(assets) {
+    return assets.map((asset) => {
+        return {
+            context: asset.input,
+            // Now we remove starting slash to make Webpack place it from the output root.
+            to: asset.output,
+            from: asset.glob,
+            globOptions: {
+                ignore: [
+                    '.gitkeep',
+                    '**/.DS_Store',
+                    '**/Thumbs.db',
+                    ...(asset.ignore ?? []),
+                ],
+                dot: true,
+            },
+        };
+    });
+}

package/src/utils/jest-utils.d.ts

@@ -0,0 +1 @@
+export declare function updateJestConfigContent(content: string): string;

package/src/utils/jest-utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJestConfigContent = updateJestConfigContent;
+function updateJestConfigContent(content) {
+    return content
+        .replace('transform: {', "transform: {\n    '^(?!.*\\\\.(js|jsx|ts|tsx|css|json)$)': '@nx/react/plugins/jest',")
+        .replace(`'babel-jest'`, `['babel-jest', { presets: ['@nx/react/babel'] }]`);
+}

package/src/utils/mode-utils.d.ts

@@ -0,0 +1,2 @@
+import { Mode } from '@rspack/core';
+export declare function isMode(mode: string): mode is Mode;

package/src/utils/mode-utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMode = isMode;
+function isMode(mode) {
+    return mode === 'development' || mode === 'production' || mode === 'none';
+}

package/src/utils/model.d.ts

@@ -0,0 +1,6 @@
+import { ExecutorContext } from '@nx/devkit';
+import { RspackExecutorSchema } from '../executors/rspack/schema';
+export interface SharedConfigContext {
+    options: RspackExecutorSchema;
+    context: ExecutorContext;
+}

package/src/utils/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils/module-federation/build-static.remotes.d.ts

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

package/src/utils/module-federation/build-static.remotes.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStaticRemotes = buildStaticRemotes;
+const fs_1 = require("fs");
+const node_child_process_1 = require("node:child_process");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const logger_1 = require("nx/src/utils/logger");
+const path_1 = require("path");
+async function buildStaticRemotes(staticRemotesConfig, nxBin, context, options) {
+    if (!staticRemotesConfig.remotes.length) {
+        return;
+    }
+    logger_1.logger.info(`NX Building ${staticRemotesConfig.remotes.length} static remotes...`);
+    const mappedLocationOfRemotes = {};
+    for (const app of staticRemotesConfig.remotes) {
+        mappedLocationOfRemotes[app] = `http${options.ssl ? 's' : ''}://${options.host}:${options.staticRemotesPort}/${staticRemotesConfig.config[app].urlSegment}`;
+    }
+    await new Promise((res, rej) => {
+        const staticProcess = (0, node_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'],
+        });
+        // File to debug build failures e.g. 2024-01-01T00_00_0_0Z-build.log'
+        const remoteBuildLogFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 
+        // eslint-disable-next-line
+        `${new Date().toISOString().replace(/[:\.]/g, '_')}-build.log`);
+        const stdoutStream = (0, fs_1.createWriteStream)(remoteBuildLogFile);
+        staticProcess.stdout.on('data', (data) => {
+            const ANSII_CODE_REGEX = 
+            // eslint-disable-next-line no-control-regex
+            /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+            const stdoutString = data.toString().replace(ANSII_CODE_REGEX, '');
+            stdoutStream.write(stdoutString);
+            // in addition to writing into the stdout stream, also show error directly in console
+            // so the error is easily discoverable. 'ERROR in' is the key word to search in webpack output.
+            if (stdoutString.includes('ERROR in')) {
+                logger_1.logger.log(stdoutString);
+            }
+            if (stdoutString.includes('Successfully ran target build')) {
+                staticProcess.stdout.removeAllListeners('data');
+                logger_1.logger.info(`NX Built ${staticRemotesConfig.remotes.length} static remotes`);
+                res();
+            }
+        });
+        staticProcess.stderr.on('data', (data) => logger_1.logger.info(data.toString()));
+        staticProcess.once('exit', (code) => {
+            stdoutStream.end();
+            staticProcess.stdout.removeAllListeners('data');
+            staticProcess.stderr.removeAllListeners('data');
+            if (code !== 0) {
+                rej(`Remote failed to start. A complete log can be found in: ${remoteBuildLogFile}`);
+            }
+            else {
+                res();
+            }
+        });
+        process.on('SIGTERM', () => staticProcess.kill('SIGTERM'));
+        process.on('exit', () => staticProcess.kill('SIGTERM'));
+    });
+    return mappedLocationOfRemotes;
+}

package/src/utils/module-federation/dependencies.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectGraph } from '@nx/devkit';
+import type { WorkspaceLibrary } from './models';
+export declare function getDependentPackagesForProject(projectGraph: ProjectGraph, name: string): {
+    workspaceLibraries: WorkspaceLibrary[];
+    npmPackages: string[];
+};

package/src/utils/module-federation/dependencies.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDependentPackagesForProject = getDependentPackagesForProject;
+const typescript_1 = require("./typescript");
+const devkit_1 = require("@nx/devkit");
+function getDependentPackagesForProject(projectGraph, name) {
+    const { npmPackages, workspaceLibraries } = collectDependencies(projectGraph, name);
+    return {
+        workspaceLibraries: [...workspaceLibraries.values()],
+        npmPackages: [...npmPackages],
+    };
+}
+function collectDependencies(projectGraph, name, dependencies = {
+    workspaceLibraries: new Map(),
+    npmPackages: new Set(),
+}, seen = new Set()) {
+    if (seen.has(name)) {
+        return dependencies;
+    }
+    seen.add(name);
+    (projectGraph.dependencies[name] ?? []).forEach((dependency) => {
+        if (dependency.target.startsWith('npm:')) {
+            dependencies.npmPackages.add(dependency.target.replace('npm:', ''));
+        }
+        else {
+            dependencies.workspaceLibraries.set(dependency.target, {
+                name: dependency.target,
+                root: projectGraph.nodes[dependency.target].data.root,
+                importKey: getLibraryImportPath(dependency.target, projectGraph),
+            });
+            collectDependencies(projectGraph, dependency.target, dependencies, seen);
+        }
+    });
+    return dependencies;
+}
+function getLibraryImportPath(library, projectGraph) {
+    let buildLibsFromSource = true;
+    if (process.env.NX_BUILD_LIBS_FROM_SOURCE) {
+        buildLibsFromSource = process.env.NX_BUILD_LIBS_FROM_SOURCE === 'true';
+    }
+    const libraryNode = projectGraph.nodes[library];
+    let sourceRoots = [libraryNode.data.sourceRoot];
+    if (!buildLibsFromSource && process.env.NX_BUILD_TARGET) {
+        const buildTarget = (0, devkit_1.parseTargetString)(process.env.NX_BUILD_TARGET, projectGraph);
+        sourceRoots = (0, devkit_1.getOutputsForTargetAndConfiguration)(buildTarget, {}, libraryNode);
+    }
+    const tsConfigPathMappings = (0, typescript_1.readTsPathMappings)();
+    for (const [key, value] of Object.entries(tsConfigPathMappings)) {
+        for (const src of sourceRoots) {
+            if (value.find((path) => path.startsWith(src))) {
+                return key;
+            }
+        }
+    }
+    return undefined;
+}

package/src/utils/module-federation/get-remotes-for-host.d.ts

@@ -0,0 +1,16 @@
+import { type ProjectGraph } from '@nx/devkit';
+import { ModuleFederationConfig } from './models';
+interface ModuleFederationExecutorContext {
+    projectName: string;
+    projectGraph: ProjectGraph;
+    root: string;
+}
+export declare function getRemotes(devRemotes: string[], skipRemotes: string[], config: ModuleFederationConfig, context: ModuleFederationExecutorContext, pathToManifestFile?: string): {
+    staticRemotes: string[];
+    devRemotes: any[];
+    dynamicRemotes: any[];
+    remotePorts: any[];
+    staticRemotePort: number;
+};
+export declare function getModuleFederationConfig(tsconfigPath: string, workspaceRoot: string, projectRoot: string, pluginName?: 'react' | 'angular'): any;
+export {};