@nx/angular 0.0.0-pr-31222-862e973 → 0.0.0-pr-31313-387cdca

package/src/generators/component/lib/normalize-options.js

@@ -4,21 +4,23 @@ exports.normalizeOptions = normalizeOptions;
 const devkit_1 = require("@nx/devkit");
 const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
 const selector_1 = require("../../utils/selector");
+const validations_1 = require("../../utils/validations");
 async function normalizeOptions(tree, options) {
     options.type ??= 'component';
     const { artifactName: name, directory, fileName, filePath, project: projectName, } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
-        artifactType: 'component',
-        callingGenerator: '@nx/angular:component',
         name: options.name,
-        directory: options.directory ?? options.path,
-        flat: options.flat,
-        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
-        project: options.project,
+        path: options.path,
         suffix: options.type ?? 'component',
+        allowedFileExtensions: ['ts'],
+        fileExtension: 'ts',
     });
+    if (name.includes('/')) {
+        throw new Error(`The component name '${name}' cannot contain a slash as it must be a valid JS symbol. Please use a different name.`);
+    }
     const { className } = (0, devkit_1.names)(name);
     const { className: suffixClassName } = (0, devkit_1.names)(options.type);
     const symbolName = `${className}${suffixClassName}`;
+    (0, validations_1.validateClassName)(symbolName);
     const { prefix, root, sourceRoot } = (0, devkit_1.readProjectConfiguration)(tree, projectName);
     const selector = options.selector ?? (0, selector_1.buildSelector)(name, options.prefix, prefix, 'fileName');
     (0, selector_1.validateHtmlSelector)(selector);

package/src/generators/component/schema.d.ts

@@ -1,9 +1,6 @@
-import type { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
-
 export interface Schema {
-  name: string;
-  directory?: string;
-  nameAndDirectoryFormat?: NameAndDirectoryFormat;
+  path: string;
+  name?: string;
   displayBlock?: boolean;
   inlineStyle?: boolean;
   inlineTemplate?: boolean;
@@ -18,21 +15,9 @@ export interface Schema {
   module?: string;
   skipSelector?: boolean;
   export?: boolean;
+  exportDefault?: boolean;
   prefix?: string;
   skipFormat?: boolean;
-
-  /**
-   * @deprecated Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20.
-   */
-  flat?: boolean;
-  /**
-   * @deprecated Provide the `directory` option instead. It will be removed in Nx v20.
-   */
-  path?: string;
-  /**
-   * @deprecated Provide the `directory` option instead. The project will be determined from the directory provided. It will be removed in Nx v20.
-   */
-  project?: string;
 }
 
 export interface NormalizedSchema extends Schema {

package/src/generators/component/schema.json

@@ -7,34 +7,18 @@
   "description": "Creates a new Angular component.",
   "additionalProperties": false,
   "properties": {
-    "name": {
+    "path": {
       "type": "string",
-      "description": "The name of the component.",
+      "description": "The file path to the component. Relative to the current working directory.",
       "$default": {
         "$source": "argv",
         "index": 0
       },
-      "x-prompt": "What name would you like to use for the component?"
-    },
-    "directory": {
-      "type": "string",
-      "description": "The directory at which to create the component file. When `--nameAndDirectoryFormat=as-provided`, it will be relative to the current working directory. Otherwise, it will be relative to the workspace root.",
-      "aliases": ["dir", "path"],
-      "x-priority": "important"
+      "x-prompt": "What is the component file path?"
     },
-    "nameAndDirectoryFormat": {
-      "description": "Whether to generate the component in the directory as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
+    "name": {
       "type": "string",
-      "enum": ["as-provided", "derived"]
-    },
-    "project": {
-      "type": "string",
-      "description": "The name of the project.",
-      "$default": {
-        "$source": "projectName"
-      },
-      "x-dropdown": "projects",
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. The project will be determined from the directory provided. It will be removed in Nx v20."
+      "description": "The component symbol name. Defaults to the last segment of the file path."
     },
     "prefix": {
       "type": "string",
@@ -94,12 +78,6 @@
       "description": "Do not create `spec.ts` test files for the new component.",
       "default": false
     },
-    "flat": {
-      "type": "boolean",
-      "description": "Create the new files at the top level of the current project.",
-      "default": false,
-      "x-deprecated": "Provide the `directory` option instead and use the `as-provided` format. It will be removed in Nx v20."
-    },
     "skipImport": {
       "type": "boolean",
       "description": "Do not import this component into the owning NgModule.",
@@ -126,6 +104,11 @@
       "default": false,
       "x-priority": "important"
     },
+    "exportDefault": {
+      "type": "boolean",
+      "default": false,
+      "description": "Use default export for the component instead of a named export."
+    },
     "skipFormat": {
       "description": "Skip formatting files.",
       "type": "boolean",
@@ -133,6 +116,6 @@
       "x-priority": "internal"
     }
   },
-  "required": ["name"],
+  "required": ["path"],
   "examplesFile": "../../../docs/component-examples.md"
 }

package/src/generators/component-story/files/__componentFileName__.stories.ts__tmpl__

@@ -1,9 +1,9 @@
 import type { Meta, StoryObj } from '@storybook/angular';
 import { <%=componentName%> } from './<%=componentFileName%>';
-<% if ( interactionTests ) { %>
+<%_ if ( interactionTests ) { _%>
 import { within } from '@storybook/testing-library';
 import { expect } from '@storybook/jest';
-<% } %>
+<%_ } _%>
 
 const meta: Meta<<%= componentName %>> = {
   component: <%= componentName %>,
@@ -18,7 +18,7 @@ export const Primary: Story = {
   },
 };
 
-<% if ( interactionTests ) { %>
+<%_ if ( interactionTests ) { _%>
 export const Heading: Story = {
   args: {<% for (let prop of props) { %>
     <%= prop.name %>: <%- prop.defaultValue %>,<% } %>
@@ -28,4 +28,4 @@ export const Heading: Story = {
     expect(canvas.getByText(/<%=componentNameSimple%> works!/gi)).toBeTruthy();
   },
 };
-<% } %>
+<%_ } _%>

package/src/generators/component-test/component-test.js

@@ -6,7 +6,7 @@ const versions_1 = require("../../utils/versions");
 const storybook_inputs_1 = require("../utils/storybook-ast/storybook-inputs");
 async function componentTestGenerator(tree, options) {
     (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
-    const { assertMinimumCypressVersion } = require('@nx/cypress/src/utils/cypress-version');
+    const { assertMinimumCypressVersion } = require('@nx/cypress/src/utils/versions');
     assertMinimumCypressVersion(10);
     const { root } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
     const componentDirPath = (0, devkit_1.joinPathFragments)(root, options.componentDir);

package/src/generators/convert-to-application-executor/convert-to-application-executor.js

@@ -26,10 +26,7 @@ const redundantExecutors = new Set([
     '@nx/angular:webpack-server',
 ]);
 async function convertToApplicationExecutor(tree, options) {
-    const { major: angularMajorVersion, version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
-    if (angularMajorVersion < 17) {
-        throw new Error(`The "convert-to-application-executor" generator is only supported in Angular >= 17.0.0. You are currently using "${angularVersion}".`);
-    }
+    const { version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
     let didAnySucceed = false;
     if (options.project) {
         (0, validations_1.validateProject)(tree, options.project);

package/src/generators/convert-to-application-executor/schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/schema",
   "$id": "NxAngularConvertToApplicationExecutorGenerator",
   "cli": "nx",
-  "title": "Converts projects to use the `@nx/angular:application` executor or the `@angular-devkit/build-angular:application` builder. _Note: this is only supported in Angular versions >= 17.0.0_.",
+  "title": "Converts projects to use the `@nx/angular:application` executor or the `@angular-devkit/build-angular:application` builder.",
   "description": "Converts a project or all projects using one of the `@angular-devkit/build-angular:browser`, `@angular-devkit/build-angular:browser-esbuild`, `@nx/angular:browser` and `@nx/angular:browser-esbuild` executors to use the `@nx/angular:application` executor or the `@angular-devkit/build-angular:application` builder. If the converted target is using one of the `@nx/angular` executors, the `@nx/angular:application` executor will be used. Otherwise, the `@angular-devkit/build-angular:application` builder will be used.",
   "type": "object",
   "properties": {

package/src/generators/convert-to-rspack/convert-to-rspack.d.ts

@@ -0,0 +1,4 @@
+import { type Tree, GeneratorCallback } from '@nx/devkit';
+import type { ConvertToRspackSchema } from './schema';
+export declare function convertToRspack(tree: Tree, schema: ConvertToRspackSchema): Promise<GeneratorCallback>;
+export default convertToRspack;

package/src/generators/convert-to-rspack/convert-to-rspack.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToRspack = convertToRspack;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+const create_config_1 = require("./lib/create-config");
+const get_custom_webpack_config_1 = require("./lib/get-custom-webpack-config");
+const update_tsconfig_1 = require("./lib/update-tsconfig");
+const validate_supported_executor_1 = require("./lib/validate-supported-executor");
+const posix_1 = require("path/posix");
+const path_1 = require("path");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const enquirer_1 = require("enquirer");
+const SUPPORTED_EXECUTORS = [
+    '@angular-devkit/build-angular:browser',
+    '@angular-devkit/build-angular:dev-server',
+    '@angular-devkit/build-angular:server',
+    '@angular-devkit/build-angular:prerender',
+    '@angular-devkit/build-angular:app-shell',
+    '@nx/angular:webpack-browser',
+    '@nx/angular:webpack-server',
+    '@nx/angular:dev-server',
+    '@nx/angular:module-federation-dev-server',
+];
+const RENAMED_OPTIONS = {
+    main: 'browser',
+    ngswConfigPath: 'serviceWorker',
+};
+const DEFAULT_PORT = 4200;
+const REMOVED_OPTIONS = ['buildOptimizer', 'buildTarget', 'browserTarget'];
+function normalizeFromProjectRoot(tree, path, projectRoot) {
+    if (projectRoot === '.') {
+        if (!path.startsWith('./')) {
+            return `./${path}`;
+        }
+        else {
+            return path;
+        }
+    }
+    else if (path.startsWith(projectRoot)) {
+        return path.replace(projectRoot, '.');
+    }
+    else if (!path.startsWith('./')) {
+        if (tree.exists(path)) {
+            const pathWithWorkspaceRoot = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, path);
+            const projectRootWithWorkspaceRoot = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot);
+            return (0, path_1.relative)(projectRootWithWorkspaceRoot, pathWithWorkspaceRoot);
+        }
+        return `./${path}`;
+    }
+    return path;
+}
+const defaultNormalizer = (tree, path, root) => normalizeFromProjectRoot(tree, path, root);
+const PATH_NORMALIZER = {
+    index: (tree, path, root) => {
+        if (typeof path === 'string') {
+            return normalizeFromProjectRoot(tree, path, root);
+        }
+        return {
+            input: normalizeFromProjectRoot(tree, path.input, root),
+            output: path.output ?? 'index.html',
+        };
+    },
+    indexHtmlTransformer: defaultNormalizer,
+    main: defaultNormalizer,
+    server: defaultNormalizer,
+    tsConfig: defaultNormalizer,
+    outputPath: (tree, path, root) => {
+        const relativePathFromWorkspaceRoot = (0, path_1.relative)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, root), devkit_1.workspaceRoot);
+        return (0, devkit_1.joinPathFragments)(relativePathFromWorkspaceRoot, path);
+    },
+    proxyConfig: defaultNormalizer,
+    polyfills: (tree, paths, root) => {
+        const normalizedPaths = [];
+        const normalizeFn = (path) => {
+            if (path.startsWith('zone.js')) {
+                normalizedPaths.push(path);
+                return;
+            }
+            try {
+                const resolvedPath = require.resolve(path, {
+                    paths: [(0, posix_1.join)(devkit_1.workspaceRoot, 'node_modules')],
+                });
+                normalizedPaths.push(path);
+            }
+            catch {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+        };
+        if (typeof paths === 'string') {
+            normalizeFn(paths);
+        }
+        else {
+            for (const path of paths) {
+                normalizeFn(path);
+            }
+        }
+        return normalizedPaths;
+    },
+    styles: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                    bundleName: path.bundleName,
+                    inject: path.inject ?? true,
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    scripts: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                    bundleName: path.bundleName,
+                    inject: path.inject ?? true,
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    assets: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            if (typeof path === 'string') {
+                normalizedPaths.push(normalizeFromProjectRoot(tree, path, root));
+            }
+            else {
+                normalizedPaths.push({
+                    ...path,
+                    input: normalizeFromProjectRoot(tree, path.input, root),
+                });
+            }
+        }
+        return normalizedPaths;
+    },
+    fileReplacements: (tree, paths, root) => {
+        const normalizedPaths = [];
+        for (const path of paths) {
+            normalizedPaths.push({
+                replace: normalizeFromProjectRoot(tree, 'src' in path ? path.src : path.replace, root),
+                with: normalizeFromProjectRoot(tree, 'replaceWith' in path ? path.replaceWith : path.with, root),
+            });
+        }
+        return normalizedPaths;
+    },
+};
+function handleBuildTargetOptions(tree, options, newConfigurationOptions, root) {
+    let customWebpackConfigPath;
+    if (!options || Object.keys(options).length === 0) {
+        return customWebpackConfigPath;
+    }
+    if (options.customWebpackConfig) {
+        customWebpackConfigPath = options.customWebpackConfig.path;
+        delete options.customWebpackConfig;
+    }
+    if (options.outputs) {
+        // handled by the Rspack inference plugin
+        delete options.outputs;
+    }
+    for (const [key, value] of Object.entries(options)) {
+        let optionName = key;
+        let optionValue = key in PATH_NORMALIZER ? PATH_NORMALIZER[key](tree, value, root) : value;
+        if (REMOVED_OPTIONS.includes(key)) {
+            continue;
+        }
+        if (key in RENAMED_OPTIONS) {
+            optionName = RENAMED_OPTIONS[key];
+        }
+        newConfigurationOptions[optionName] = optionValue;
+    }
+    if (typeof newConfigurationOptions.polyfills === 'string') {
+        newConfigurationOptions.polyfills = [newConfigurationOptions.polyfills];
+    }
+    let outputPath = newConfigurationOptions.outputPath;
+    if (typeof outputPath === 'string') {
+        if (!/\/browser\/?$/.test(outputPath)) {
+            console.warn(`The output location of the browser build has been updated from "${outputPath}" to ` +
+                `"${(0, posix_1.join)(outputPath, 'browser')}". ` +
+                'You might need to adjust your deployment pipeline or, as an alternative, ' +
+                'set outputPath.browser to "" in order to maintain the previous functionality.');
+        }
+        else {
+            outputPath = outputPath.replace(/\/browser\/?$/, '');
+        }
+        newConfigurationOptions['outputPath'] = {
+            base: outputPath,
+        };
+        if (typeof newConfigurationOptions.resourcesOutputPath === 'string') {
+            const media = newConfigurationOptions.resourcesOutputPath.replaceAll('/', '');
+            if (media && media !== 'media') {
+                newConfigurationOptions['outputPath'] = {
+                    base: outputPath,
+                    media,
+                };
+            }
+        }
+    }
+    return customWebpackConfigPath;
+}
+function handleDevServerTargetOptions(tree, options, newConfigurationOptions, root) {
+    for (const [key, value] of Object.entries(options)) {
+        let optionName = key;
+        let optionValue = key in PATH_NORMALIZER ? PATH_NORMALIZER[key](tree, value, root) : value;
+        if (REMOVED_OPTIONS.includes(key)) {
+            continue;
+        }
+        if (key in RENAMED_OPTIONS) {
+            optionName = RENAMED_OPTIONS[key];
+        }
+        newConfigurationOptions[optionName] = optionValue;
+    }
+}
+async function getProjectToConvert(tree) {
+    const projects = new Set();
+    for (const executor of SUPPORTED_EXECUTORS) {
+        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (_, project) => {
+            projects.add(project);
+        });
+    }
+    const { project } = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'project',
+        message: 'Which project would you like to convert to rspack?',
+        choices: Array.from(projects),
+    });
+    return project;
+}
+async function convertToRspack(tree, schema) {
+    let { project: projectName } = schema;
+    if (!projectName) {
+        projectName = await getProjectToConvert(tree);
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const tasks = [];
+    const createConfigOptions = {
+        root: project.root,
+    };
+    const configurationOptions = {};
+    const buildTargetNames = [];
+    const serveTargetNames = [];
+    let customWebpackConfigPath;
+    (0, validate_supported_executor_1.validateSupportedBuildExecutor)(Object.values(project.targets));
+    let projectServePort = DEFAULT_PORT;
+    for (const [targetName, target] of Object.entries(project.targets)) {
+        if (target.executor === '@angular-devkit/build-angular:browser' ||
+            target.executor === '@nx/angular:webpack-browser') {
+            customWebpackConfigPath = handleBuildTargetOptions(tree, target.options, createConfigOptions, project.root);
+            if (target.configurations) {
+                for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                    configurationOptions[configurationName] = {};
+                    handleBuildTargetOptions(tree, configuration, configurationOptions[configurationName], project.root);
+                }
+            }
+            buildTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:server' ||
+            target.executor === '@nx/angular:webpack-server') {
+            createConfigOptions.ssr ??= {};
+            createConfigOptions.ssr.entry ??= normalizeFromProjectRoot(tree, target.options.main, project.root);
+            createConfigOptions.server = './src/main.server.ts';
+            buildTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:dev-server' ||
+            target.executor === '@nx/angular:dev-server' ||
+            target.executor === '@nx/angular:module-federation-dev-server') {
+            createConfigOptions.devServer = {};
+            if (target.options) {
+                handleDevServerTargetOptions(tree, target.options, createConfigOptions.devServer, project.root);
+                if (target.options.port !== DEFAULT_PORT) {
+                    projectServePort = target.options.port;
+                }
+            }
+            if (target.configurations) {
+                for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                    configurationOptions[configurationName] ??= {};
+                    configurationOptions[configurationName].devServer ??= {};
+                    handleDevServerTargetOptions(tree, configuration, configurationOptions[configurationName].devServer, project.root);
+                }
+            }
+            serveTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:prerender') {
+            if (target.options) {
+                const prerenderOptions = {
+                    routesFile: target.options.routesFile,
+                    discoverRoutes: target.options.discoverRoutes ?? true,
+                    routes: target.options.routes ?? [],
+                };
+                createConfigOptions.prerender = prerenderOptions;
+                if (target.configurations) {
+                    for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                        configurationOptions[configurationName] ??= {};
+                        configurationOptions[configurationName].prerender ??= {
+                            routesFile: configuration.routesFile,
+                            discoverRoutes: configuration.discoverRoutes ?? true,
+                            routes: configuration.routes ?? [],
+                        };
+                    }
+                }
+            }
+            buildTargetNames.push(targetName);
+        }
+        else if (target.executor === '@angular-devkit/build-angular:app-shell') {
+            createConfigOptions.appShell = true;
+            buildTargetNames.push(targetName);
+        }
+    }
+    const customWebpackConfigInfo = customWebpackConfigPath
+        ? await (0, get_custom_webpack_config_1.getCustomWebpackConfig)(tree, project.root, customWebpackConfigPath)
+        : undefined;
+    (0, create_config_1.createConfig)(tree, createConfigOptions, configurationOptions, customWebpackConfigInfo?.normalizedPathToCustomWebpackConfig, customWebpackConfigInfo?.isWebpackConfigFunction);
+    (0, update_tsconfig_1.updateTsconfig)(tree, project.root);
+    for (const targetName of [...buildTargetNames, ...serveTargetNames]) {
+        delete project.targets[targetName];
+    }
+    if (projectServePort !== DEFAULT_PORT) {
+        project.targets.serve ??= {};
+        project.targets.serve.options ??= {};
+        project.targets.serve.options.port = projectServePort;
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, projectName, project);
+    const { rspackInitGenerator } = (0, devkit_1.ensurePackage)('@nx/rspack', versions_1.nxVersion);
+    await rspackInitGenerator(tree, {
+        addPlugin: true,
+        framework: 'angular',
+    });
+    // This is needed to prevent a circular execution of the build target
+    const rootPkgJson = (0, devkit_1.readJson)(tree, 'package.json');
+    if (rootPkgJson.scripts?.build === 'nx build') {
+        delete rootPkgJson.scripts.build;
+        (0, devkit_1.writeJson)(tree, 'package.json', rootPkgJson);
+    }
+    if (!schema.skipInstall) {
+        const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/angular-rspack': versions_1.angularRspackVersion,
+            'webpack-merge': versions_1.webpackMergeVersion,
+            'ts-node': versions_1.tsNodeVersion,
+        });
+        tasks.push(installTask);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = convertToRspack;

package/src/generators/convert-to-rspack/lib/create-config.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function createConfig(tree: Tree, opts: Record<string, any>, configurationOptions?: Record<string, Record<string, any>>, existingWebpackConfigPath?: string, isExistingWebpackConfigFunction?: boolean): void;

package/src/generators/convert-to-rspack/lib/create-config.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfig = createConfig;
+const devkit_1 = require("@nx/devkit");
+function createConfig(tree, opts, configurationOptions = {}, existingWebpackConfigPath, isExistingWebpackConfigFunction) {
+    const { root, ...createConfigOptions } = opts;
+    const hasConfigurations = Object.keys(configurationOptions).length > 0;
+    const expandedConfigurationOptions = hasConfigurations
+        ? Object.entries(configurationOptions)
+            .map(([configurationName, configurationOptions]) => {
+            return `
+      "${configurationName}": {
+        options: {
+          ${JSON.stringify(configurationOptions, undefined, 2).slice(1, -1)}
+        }
+      }`;
+        })
+            .join(',\n')
+        : '';
+    const createConfigContents = `createConfig({ 
+    options: {
+      root: __dirname,
+      ${JSON.stringify(createConfigOptions, undefined, 2).slice(1, -1)}
+    }
+  }${hasConfigurations ? `, {${expandedConfigurationOptions}}` : ''});`;
+    const configContents = `
+  import { createConfig }from '@nx/angular-rspack';
+  ${existingWebpackConfigPath
+        ? `import baseWebpackConfig from '${existingWebpackConfigPath}';
+      ${isExistingWebpackConfigFunction
+            ? ''
+            : `import webpackMerge from 'webpack-merge';`}`
+        : ''}
+  
+  ${existingWebpackConfigPath
+        ? `export default async () => {
+        const baseConfig = await ${createConfigContents}
+        ${isExistingWebpackConfigFunction
+            ? `const oldConfig = await baseWebpackConfig;
+        const browserConfig = baseConfig[0];
+        return oldConfig(browserConfig);`
+            : 'return webpackMerge(baseConfig[0], baseWebpackConfig);'}};`
+        : `export default ${createConfigContents}`}`;
+    tree.write((0, devkit_1.joinPathFragments)(root, 'rspack.config.ts'), configContents);
+}

package/src/generators/convert-to-rspack/lib/get-custom-webpack-config.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+export declare function getCustomWebpackConfig(tree: Tree, projectRoot: string, pathToCustomWebpackConfig: string): Promise<{
+    isWebpackConfigFunction: boolean;
+    normalizedPathToCustomWebpackConfig: string;
+}>;
+export declare function convertWebpackConfigToUseNxModuleFederationPlugin(webpackConfigContents: string): string;