@nx/rspack 20.2.0-beta.2 → 20.2.0-beta.4

package/src/plugins/nx-app-rspack-plugin/nx-app-rspack-plugin.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxAppRspackPlugin = void 0;
+const normalize_options_1 = require("../utils/plugins/normalize-options");
+const apply_base_config_1 = require("../utils/apply-base-config");
+const apply_web_config_1 = require("../utils/apply-web-config");
+/**
+ * This plugin provides features to build Node and Web applications.
+ * - TS Support (including tsconfig paths
+ * - Assets handling
+ * - Stylesheets handling
+ * - index.html and package.json generation
+ *
+ * Web-only features, such as stylesheets and images, are only supported when `target` is `web` or `webworker`.
+ */
+class NxAppRspackPlugin {
+    constructor(options = {}) {
+        // If we're building inferred targets, skip normalizing the build options
+        if (!global.NX_GRAPH_CREATION) {
+            this.options = (0, normalize_options_1.normalizeOptions)(options);
+        }
+    }
+    apply(compiler) {
+        // Default's to web
+        const target = this.options.target ?? compiler.options.target;
+        this.options.outputPath ??= compiler.options.output?.path;
+        if (typeof target === 'string') {
+            this.options.target = target;
+        }
+        (0, apply_base_config_1.applyBaseConfig)(this.options, compiler.options, {
+            useNormalizedEntry: true,
+        });
+        if (compiler.options.target) {
+            this.options.target = compiler.options.target;
+        }
+        if (this.options.target === 'web' || this.options.target === 'webworker') {
+            (0, apply_web_config_1.applyWebConfig)(this.options, compiler.options, {
+                useNormalizedEntry: true,
+            });
+        }
+    }
+}
+exports.NxAppRspackPlugin = NxAppRspackPlugin;

package/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Compiler } from '@rspack/core';
+export declare class NxReactRspackPlugin {
+    private options;
+    constructor(options?: {
+        svgr?: boolean;
+    });
+    apply(compiler: Compiler): void;
+}

package/src/plugins/nx-react-rspack-plugin/nx-react-rspack-plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxReactRspackPlugin = void 0;
+const apply_react_config_1 = require("../utils/apply-react-config");
+class NxReactRspackPlugin {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        (0, apply_react_config_1.applyReactConfig)(this.options, compiler.options);
+    }
+}
+exports.NxReactRspackPlugin = NxReactRspackPlugin;

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.d.ts

@@ -0,0 +1,31 @@
+import type { NxRspackExecutionContext } from '../../utils/config';
+import type { NxAppRspackPluginOptions } from '../utils/models';
+import type { Compiler, Configuration } from '@rspack/core';
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the rspack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+ withNx(),
+ (config) => {
+ return config;
+ }
+ );
+
+ Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+ Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+ The context options are created and passed to the legacy plugin function.
+
+ module.exports = async () => ({
+ plugins: [
+ ...otherPlugins,
+ await nxUseLegacyPlugin(require({path}), options),
+ ],
+ });
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Rspack configuration
+ */
+export declare function useLegacyNxPlugin(fn: (config: Configuration, ctx: NxRspackExecutionContext) => Promise<Configuration>, executorOptions: NxAppRspackPluginOptions): Promise<{
+    apply(compiler: Compiler): void;
+}>;

package/src/plugins/use-legacy-nx-plugin/use-legacy-nx-plugin.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLegacyNxPlugin = useLegacyNxPlugin;
+const devkit_1 = require("@nx/devkit");
+const normalize_options_1 = require("../utils/plugins/normalize-options");
+const configuration_1 = require("nx/src/config/configuration");
+/**
+ * This function is used to wrap the legacy plugin function to be used with the `composePlugins` function.
+ * Initially the rspack config would be passed to the legacy plugin function and the options would be passed as a second argument.
+ * example:
+ * module.exports = composePlugins(
+ withNx(),
+ (config) => {
+ return config;
+ }
+ );
+
+ Since composePlugins is async, this function is used to wrap the legacy plugin function to be async.
+ Using the nxUseLegacyPlugin function, the first argument is the legacy plugin function and the second argument is the options.
+ The context options are created and passed to the legacy plugin function.
+
+ module.exports = async () => ({
+ plugins: [
+ ...otherPlugins,
+ await nxUseLegacyPlugin(require({path}), options),
+ ],
+ });
+ * @param fn The legacy plugin function usually from `combinedPlugins`
+ * @param executorOptions The options passed usually inside the executor or the config file
+ * @returns Rspack configuration
+ */
+async function useLegacyNxPlugin(fn, executorOptions) {
+    if (global.NX_GRAPH_CREATION) {
+        return;
+    }
+    const options = (0, normalize_options_1.normalizeOptions)(executorOptions);
+    const projectGraph = (0, devkit_1.readCachedProjectGraph)();
+    const projectName = process.env.NX_TASK_TARGET_PROJECT;
+    const project = projectGraph.nodes[projectName];
+    const targetName = process.env.NX_TASK_TARGET_TARGET;
+    const context = {
+        cwd: process.cwd(),
+        isVerbose: process.env.NX_VERBOSE_LOGGING === 'true',
+        root: devkit_1.workspaceRoot,
+        projectGraph,
+        projectsConfigurations: (0, devkit_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+        nxJsonConfiguration: (0, configuration_1.readNxJson)(devkit_1.workspaceRoot),
+        target: project.data.targets[targetName],
+        targetName: targetName,
+        projectName: projectName,
+    };
+    const configuration = process.env.NX_TASK_TARGET_CONFIGURATION;
+    const ctx = {
+        context,
+        options: options,
+        configuration,
+    };
+    return {
+        apply(compiler) {
+            compiler.hooks.beforeCompile.tapPromise('NxLegacyAsyncPlugin', () => {
+                return new Promise((resolve) => {
+                    fn(compiler.options, ctx).then((updated) => {
+                        // Merge options back shallowly since it's a fully functional configuration.
+                        // Most likely, the user modified the config in place, but this guarantees that updates are applied if users did something like:
+                        // `return { ...config, plugins: [...config.plugins, new MyPlugin()] }`
+                        Object.assign(compiler.options, updated);
+                        resolve();
+                    });
+                });
+            });
+        },
+    };
+}

package/src/plugins/utils/apply-base-config.js

@@ -26,6 +26,7 @@ function applyBaseConfig(options, config = {}, { useNormalizedEntry, } = {}) {
     options.memoryLimit ??= 2048;
     options.transformers ??= [];
     options.progress ??= true;
+    options.outputHashing ??= 'all';
     applyNxIndependentConfig(options, config);
     // Some of the options only work during actual tasks, not when reading the rspack config during CreateNodes.
     if (global.NX_GRAPH_CREATION)
@@ -79,6 +80,7 @@ function applyNxIndependentConfig(options, config) {
         hashFunction: config.output?.hashFunction ?? 'xxhash64',
         // Disabled for performance
         pathinfo: config.output?.pathinfo ?? false,
+        clean: options.deleteOutputPath,
     };
     config.watch = options.watch;
     config.watchOptions = {
@@ -91,6 +93,7 @@ function applyNxIndependentConfig(options, config) {
     };
     config.ignoreWarnings = [
         (x) => IGNORED_RSPACK_WARNINGS.some((r) => typeof x === 'string' ? r.test(x) : r.test(x.message)),
+        ...(config.ignoreWarnings ?? []),
     ];
     config.optimization = !isProd
         ? undefined

package/src/plugins/utils/apply-web-config.d.ts

@@ -1,5 +1,5 @@
-import { type Configuration } from '@rspack/core';
+import { type Configuration, RspackOptionsNormalized } from '@rspack/core';
 import { NormalizedNxAppRspackPluginOptions } from './models';
-export declare function applyWebConfig(options: NormalizedNxAppRspackPluginOptions, config?: Configuration, { useNormalizedEntry, }?: {
+export declare function applyWebConfig(options: NormalizedNxAppRspackPluginOptions, config?: Partial<RspackOptionsNormalized | Configuration>, { useNormalizedEntry, }?: {
     useNormalizedEntry?: boolean;
 }): void;

package/src/plugins/utils/apply-web-config.js

@@ -283,7 +283,7 @@ function applyWebConfig(options, config = {}, { useNormalizedEntry, } = {}) {
         }
     });
     config.optimization = !isProd
-        ? undefined
+        ? {}
         : {
             ...(config.optimization ?? {}),
             minimizer: [...(config.optimization?.minimizer ?? []), ...minimizer],

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

@@ -81,7 +81,7 @@ function normalizeOptions(options) {
         sourceMap: combinedPluginAndMaybeExecutorOptions.sourceMap ?? !isProd,
         sourceRoot,
         styles: combinedPluginAndMaybeExecutorOptions.styles ?? [],
-        target: combinedPluginAndMaybeExecutorOptions.target,
+        target: combinedPluginAndMaybeExecutorOptions.target ?? 'web',
         targetName,
         vendorChunk: combinedPluginAndMaybeExecutorOptions.vendorChunk ?? !isProd,
     };

package/src/plugins/utils/plugins/nx-tsconfig-paths-rspack-plugin.js

@@ -16,7 +16,7 @@ class NxTsconfigPathsRspackPlugin {
     apply(compiler) {
         // TODO(Colum): Investigate the best way to handle this, currently it is not working and affecting HMR
         // // If we are not building libs from source, we need to remap paths so tsconfig may be updated.
-        // this.handleBuildLibsFromSource(compiler.options, this.options);
+        this.handleBuildLibsFromSource(compiler.options, this.options);
         const pathToTsconfig = !path.isAbsolute(this.options.tsConfig)
             ? path.join(devkit_1.workspaceRoot, this.options.tsConfig)
             : this.options.tsConfig;
@@ -44,7 +44,8 @@ class NxTsconfigPathsRspackPlugin {
         if (!options.buildLibsFromSource && options.targetName) {
             const remappedTarget = options.targetName === 'serve' ? 'build' : options.targetName;
             const { target, dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(undefined, options.projectGraph, options.root, options.projectName, remappedTarget, options.configurationName);
-            options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies);
+            options.tsConfig = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, options.root, target.data.root, dependencies, true // There is an issue with Rspack that requires the baseUrl to be set in the generated tsconfig
+            );
             this.tmpTsConfigPath = options.tsConfig;
             if (options.targetName === 'serve') {
                 const buildableDependencies = dependencies

package/src/utils/create-compiler.js

@@ -6,7 +6,9 @@ const core_1 = require("@rspack/core");
 const config_1 = require("../executors/rspack/lib/config");
 async function createCompiler(options, context) {
     const config = await (0, config_1.getRspackConfigs)(options, context);
-    validateConfig(config);
+    if (!options.standardRspackConfigFunction) {
+        validateConfig(config);
+    }
     return (0, core_1.rspack)(config);
 }
 function isMultiCompiler(compiler) {

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

@@ -1,6 +1,6 @@
 import { TargetConfiguration, Tree } from '@nx/devkit';
-import { ConfigurationSchema } from '../generators/configuration/schema';
-import { Framework } from '../generators/init/schema';
+import { type ConfigurationSchema } from '../generators/configuration/schema';
+import { type Framework } from '../generators/init/schema';
 export type Target = 'build' | 'serve';
 export type TargetFlags = Partial<Record<Target, boolean>>;
 export type UserProvidedTargetName = Partial<Record<Target, string>>;

package/src/utils/generator-utils.js

@@ -15,6 +15,7 @@ exports.determineMain = determineMain;
 exports.determineTsConfig = determineTsConfig;
 const devkit_1 = require("@nx/devkit");
 const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const has_plugin_1 = require("./has-plugin");
 function findExistingTargetsInProject(targets, userProvidedTargets) {
     const output = {
         validFoundTargetName: {},
@@ -177,82 +178,148 @@ function addOrChangeServeTarget(tree, options, target) {
 }
 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));
+    tree.write((0, devkit_1.joinPathFragments)(project.root, 'rspack.config.js'), createConfig(tree, { ...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;
-      });
-    `;
+function createConfig(tree, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const buildOptions = createBuildOptions(tree, options, project);
+    const defaultConfig = generateDefaultConfig(project, buildOptions);
+    if (isWebFramework(options)) {
+        return generateWebConfig(tree, options, defaultConfig);
     }
-    else if (options.framework === 'web' || options.target === 'web') {
-        return `
-      const { composePlugins, withNx, withWeb } = require('@nx/rspack');
+    else if (options.framework === 'nest') {
+        return generateNestConfig(tree, options, project, buildOptions);
+    }
+    else {
+        return generateGenericConfig(tree, options, defaultConfig);
+    }
+}
+function createBuildOptions(tree, options, project) {
+    return {
+        target: options.target ?? 'web',
+        outputPath: (0, devkit_1.joinPathFragments)('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'),
+    };
+}
+function generateDefaultConfig(project, buildOptions) {
+    return `
+const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+const { join } = require('path');
 
-      module.exports = composePlugins(withNx(), withWeb(${stylePreprocessorOptions
-            ? `
-        {
-          stylePreprocessorOptions: ${JSON.stringify(stylePreprocessorOptions)},
-        }
-        `
-            : ''}), (config) => {
-        return config;
-      });
-    `;
+module.exports = {
+  output: {
+    path: join(__dirname, '${(0, devkit_1.offsetFromRoot)(project.root)}${buildOptions.outputPath}'),
+  },
+  plugins: [
+    new NxAppRspackPlugin({
+      target: '${buildOptions.target}',
+      tsConfig: '${buildOptions.tsConfig}',
+      main: '${buildOptions.main}',
+      outputHashing: '${buildOptions.target !== 'web' ? 'none' : 'all'}',
+    })
+  ]
+}`;
+}
+function isWebFramework(options) {
+    return options.framework === 'web' || options.target === 'web';
+}
+function generateWebConfig(tree, options, defaultConfig) {
+    if ((0, has_plugin_1.hasPlugin)(tree)) {
+        return defaultConfig;
     }
-    else if (options.framework === 'nest') {
+    return `
+const { composePlugins, withNx, withWeb } = require('@nx/rspack');
+module.exports = composePlugins(withNx(), withWeb(${options.stylePreprocessorOptions
+        ? `
+  {
+    stylePreprocessorOptions: ${JSON.stringify(options.stylePreprocessorOptions)},
+  }
+  `
+        : ''}), (config) => {
+    return config;
+  });
+`;
+}
+function generateNestConfig(tree, options, project, buildOptions) {
+    if ((0, has_plugin_1.hasPlugin)(tree)) {
         return `
-    const { composePlugins, withNx } = require('@nx/rspack');
-    const rspack = require('@rspack/core');
+const { NxAppRspackPlugin } = require('@nx/rspack/app-plugin');
+const rspack = require('@rspack/core');
+const { join } = require('path');
 
-    module.exports = composePlugins(withNx(), (config) => {
-      config.optimization = {
-        minimizer: [
-          new rspack.SwcJsMinimizerRspackPlugin({
-            minimizerOptions: {
-              // We need to disable mangling and compression for class names and function names for Nest.js to work properly
-              // The execution context class returns a reference to the class/handler function, which is for example used for applying metadata using decorators
-              // https://docs.nestjs.com/fundamentals/execution-context#executioncontext-class
-              compress: {
-                keep_classnames: true,
-                keep_fnames: true,
-              },
-              mangle: {
-                keep_classnames: true,
-                keep_fnames: true,
-              },
-            },
-          }),
-        ],
-      };
-      return config;
-    });
-    `;
+module.exports = {
+  output: {
+    path: join(__dirname, '${(0, devkit_1.offsetFromRoot)(project.root)}${buildOptions.outputPath}'),
+  },
+  optimization: {
+    minimizer: [
+      new rspack.SwcJsMinimizerRspackPlugin({
+        minimizerOptions: {
+          compress: {
+            keep_classnames: true,
+            keep_fnames: true,
+          },
+          mangle: {
+            keep_classnames: true,
+            keep_fnames: true,
+          },
+        },
+      }),
+    ],
+  },
+  plugins: [
+    new NxAppRspackPlugin({
+      target: '${buildOptions.target}',
+      tsConfig: '${buildOptions.tsConfig}',
+      main: '${buildOptions.main}',
+      outputHashing: '${buildOptions.target !== 'web' ? 'none' : 'all'}',
+    })
+  ]
+}`;
     }
-    else {
-        return `
-      const { composePlugins, withNx${stylePreprocessorOptions ? ', withWeb' : ''} } = require('@nx/rspack');
+    return `
+const { composePlugins, withNx } = require('@nx/rspack');
+const rspack = require('@rspack/core');
 
-      module.exports = composePlugins(withNx()${stylePreprocessorOptions
-            ? `,
-        withWeb({
-          stylePreprocessorOptions: ${JSON.stringify(stylePreprocessorOptions)},
-        })`
-            : ''}, (config) => {
-        return config;
-      });
-    `;
+module.exports = composePlugins(withNx(), (config) => {
+  config.optimization = {
+    minimizer: [
+      new rspack.SwcJsMinimizerRspackPlugin({
+        minimizerOptions: {
+          compress: {
+            keep_classnames: true,
+            keep_fnames: true,
+          },
+          mangle: {
+            keep_classnames: true,
+            keep_fnames: true,
+          },
+        },
+      }),
+    ],
+  };
+  return config;
+});
+`;
+}
+function generateGenericConfig(tree, options, defaultConfig) {
+    if ((0, has_plugin_1.hasPlugin)(tree)) {
+        return defaultConfig;
     }
+    return `
+const { composePlugins, withNx${options.stylePreprocessorOptions ? ', withWeb' : ''} } = require('@nx/rspack');
+
+module.exports = composePlugins(withNx()${options.stylePreprocessorOptions
+        ? `,
+    withWeb({
+      stylePreprocessorOptions: ${JSON.stringify(options.stylePreprocessorOptions)},
+    })`
+        : ''}, (config) => {
+    return config;
+  });
+`;
 }
 function deleteWebpackConfig(tree, projectRoot, webpackConfigFilePath) {
     const webpackConfigPath = webpackConfigFilePath && tree.exists(webpackConfigFilePath)

package/src/utils/has-plugin.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasPlugin(tree: Tree): boolean;

package/src/utils/has-plugin.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPlugin = hasPlugin;
+const devkit_1 = require("@nx/devkit");
+function hasPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    return !!nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/rspack/plugin'
+        : p.plugin === '@nx/rspack/plugin');
+}

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

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

package/src/utils/versions.d.ts

@@ -1,6 +1,6 @@
 export declare const nxVersion: any;
-export declare const rspackCoreVersion = "1.0.5";
-export declare const rspackDevServerVersion = "1.0.5";
+export declare const rspackCoreVersion = "1.1.2";
+export declare const rspackDevServerVersion = "1.0.9";
 export declare const rspackPluginMinifyVersion = "^0.7.5";
 export declare const rspackPluginReactRefreshVersion = "^1.0.0";
 export declare const lessLoaderVersion = "~11.1.3";

package/src/utils/versions.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.eslintPluginReactHooksVersion = exports.eslintPluginReactVersion = exports.eslintPluginJsxA11yVersion = exports.eslintPluginImportVersion = exports.stylusVersion = exports.sassVersion = exports.lessVersion = exports.nestjsMicroservicesVersion = exports.nestjsPlatformExpressVersion = exports.nestjsCoreVersion = exports.nestjsCommonVersion = exports.typesReactDomVersion = exports.typesReactVersion = exports.reactDomVersion = exports.reactRefreshVersion = exports.reactVersion = exports.lessLoaderVersion = exports.rspackPluginReactRefreshVersion = exports.rspackPluginMinifyVersion = exports.rspackDevServerVersion = exports.rspackCoreVersion = exports.nxVersion = void 0;
 exports.nxVersion = require('../../package.json').version;
-exports.rspackCoreVersion = '1.0.5';
-exports.rspackDevServerVersion = '1.0.5';
+exports.rspackCoreVersion = '1.1.2';
+exports.rspackDevServerVersion = '1.0.9';
 exports.rspackPluginMinifyVersion = '^0.7.5';
 exports.rspackPluginReactRefreshVersion = '^1.0.0';
 exports.lessLoaderVersion = '~11.1.3';

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

@@ -1,6 +0,0 @@
-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

@@ -1,56 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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 {};