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

package/src/generators/application/lib/add-jest.js

@@ -3,18 +3,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addJest = addJest;
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../../utils/versions");
+const node_path_1 = require("node:path");
 async function addJest(host, options) {
     if (options.unitTestRunner === 'none') {
         return () => { };
     }
     const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/jest', versions_1.nxVersion);
-    return await configurationGenerator(host, {
+    await configurationGenerator(host, {
         ...options,
         project: options.projectName,
         supportTsx: true,
         skipSerializers: true,
-        setupFile: 'none',
+        setupFile: options.useReactRouter ? 'react-router' : 'none',
         compiler: options.compiler,
         skipFormat: true,
+        runtimeTsconfigFileName: 'tsconfig.app.json',
     });
+    if (options.useReactRouter) {
+        (0, devkit_1.updateJson)(host, (0, node_path_1.join)(options.appProjectRoot, 'tsconfig.spec.json'), (json) => {
+            json.include = json.include ?? [];
+            const reactRouterTestGlob = options.js
+                ? [
+                    'test/**/*.spec.jsx',
+                    'test/**/*.spec.js',
+                    'test/**/*.test.jsx',
+                    'test/**/*.test.js',
+                ]
+                : [
+                    'test/**/*.spec.tsx',
+                    'test/**/*.spec.ts',
+                    'test/**/*.test.tsx',
+                    'test/**/*.test.ts',
+                ];
+            return {
+                ...json,
+                include: Array.from(new Set([...json.include, ...reactRouterTestGlob])),
+            };
+        });
+    }
+    return () => { };
 }

package/src/generators/application/lib/add-linting.d.ts

@@ -0,0 +1,4 @@
+import { type Tree, type GeneratorCallback } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+export declare function addLinting(host: Tree, options: NormalizedSchema): Promise<GeneratorCallback>;
+export declare function isEslintInstalled(tree: Tree): boolean;

package/src/generators/application/lib/add-linting.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLinting = addLinting;
+exports.isEslintInstalled = isEslintInstalled;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const eslint_file_1 = require("@nx/eslint/src/generators/utils/eslint-file");
+const flat_config_1 = require("@nx/eslint/src/utils/flat-config");
+const devkit_2 = require("@nx/devkit");
+const add_swc_dependencies_1 = require("@nx/js/src/utils/swc/add-swc-dependencies");
+const lint_1 = require("../../../utils/lint");
+const versions_1 = require("../../../utils/versions");
+async function addLinting(host, options) {
+    const tasks = [];
+    if (options.linter === 'eslint') {
+        const lintTask = await (0, eslint_1.lintProjectGenerator)(host, {
+            linter: options.linter,
+            project: options.projectName,
+            tsConfigPaths: [
+                (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.app.json'),
+            ],
+            unitTestRunner: options.unitTestRunner,
+            skipFormat: true,
+            rootProject: options.rootProject,
+            skipPackageJson: options.skipPackageJson,
+            addPlugin: options.addPlugin,
+        });
+        tasks.push(lintTask);
+        if ((0, eslint_file_1.isEslintConfigSupported)(host)) {
+            if ((0, flat_config_1.useFlatConfig)(host)) {
+                (0, eslint_file_1.addPredefinedConfigToFlatLintConfig)(host, options.appProjectRoot, 'flat/react');
+                // Add an empty rules object to users know how to add/override rules
+                (0, eslint_file_1.addOverrideToLintConfig)(host, options.appProjectRoot, {
+                    files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+                    rules: {},
+                });
+            }
+            else {
+                const addExtendsTask = (0, eslint_file_1.addExtendsToLintConfig)(host, options.appProjectRoot, { name: 'plugin:@nx/react', needCompatFixup: true });
+                tasks.push(addExtendsTask);
+            }
+        }
+        if (!options.skipPackageJson) {
+            const installTask = (0, devkit_2.addDependenciesToPackageJson)(host, lint_1.extraEslintDependencies.dependencies, lint_1.extraEslintDependencies.devDependencies);
+            const addSwcTask = (0, add_swc_dependencies_1.addSwcDependencies)(host);
+            tasks.push(installTask, addSwcTask);
+        }
+        if (options.useReactRouter) {
+            await ignoreReactRouterFilesInEslintConfig(host, options.appProjectRoot);
+        }
+    }
+    return (0, devkit_2.runTasksInSerial)(...tasks);
+}
+async function ignoreReactRouterFilesInEslintConfig(tree, projectRoot) {
+    if (!isEslintInstalled(tree)) {
+        return;
+    }
+    (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    const { addIgnoresToLintConfig, isEslintConfigSupported } = await Promise.resolve().then(() => require('@nx/eslint/src/generators/utils/eslint-file'));
+    if (!isEslintConfigSupported(tree)) {
+        return;
+    }
+    const { useFlatConfig } = await Promise.resolve().then(() => require('@nx/eslint/src/utils/flat-config'));
+    const isUsingFlatConfig = useFlatConfig(tree);
+    if (!projectRoot && !isUsingFlatConfig) {
+        // root eslintrc files ignore all files and the root eslintrc files add
+        // back all the project files, so we only add the ignores to the project
+        // eslintrc files
+        return;
+    }
+    // for flat config, we update the root config file
+    const directory = isUsingFlatConfig ? '' : projectRoot ?? '';
+    addIgnoresToLintConfig(tree, directory, ['**/build', '**/.react-router']);
+}
+function isEslintInstalled(tree) {
+    try {
+        require('eslint');
+        return true;
+    }
+    catch { }
+    // it might not be installed yet, but it might be in the tree pending install
+    const { devDependencies, dependencies } = tree.exists('package.json')
+        ? (0, devkit_1.readJson)(tree, 'package.json')
+        : {};
+    return !!devDependencies?.['eslint'] || !!dependencies?.['eslint'];
+}

package/src/generators/application/lib/add-project.js

@@ -4,6 +4,7 @@ exports.addProject = addProject;
 const devkit_1 = require("@nx/devkit");
 const has_webpack_plugin_1 = require("../../../utils/has-webpack-plugin");
 const maybe_js_1 = require("../../../utils/maybe-js");
+const has_rspack_plugin_1 = require("../../../utils/has-rspack-plugin");
 function addProject(host, options) {
     const project = {
         root: options.appProjectRoot,
@@ -20,9 +21,112 @@ function addProject(host, options) {
             };
         }
     }
-    (0, devkit_1.addProjectConfiguration)(host, options.projectName, {
-        ...project,
-    });
+    else if (options.bundler === 'rspack' &&
+        (!(0, has_rspack_plugin_1.hasRspackPlugin)(host) || !options.addPlugin)) {
+        project.targets = {
+            build: createRspackBuildTarget(options),
+            serve: createRspackServeTarget(options),
+        };
+    }
+    const packageJson = {
+        name: options.importPath,
+        version: '0.0.1',
+        private: true,
+    };
+    if (!options.useProjectJson) {
+        if (options.projectName !== options.importPath) {
+            packageJson.nx = { name: options.projectName };
+        }
+        if (Object.keys(project.targets).length) {
+            packageJson.nx ??= {};
+            packageJson.nx.targets = project.targets;
+        }
+        if (options.parsedTags?.length) {
+            packageJson.nx ??= {};
+            packageJson.nx.tags = options.parsedTags;
+        }
+    }
+    else {
+        (0, devkit_1.addProjectConfiguration)(host, options.projectName, {
+            ...project,
+        });
+    }
+    if (!options.useProjectJson || options.isUsingTsSolutionConfig) {
+        // React Router already adds a package.json to the project root
+        if (options.useReactRouter) {
+            (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'package.json'), (json) => {
+                return {
+                    name: packageJson.name,
+                    ...json,
+                };
+            });
+        }
+        else {
+            (0, devkit_1.writeJson)(host, (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'package.json'), packageJson);
+        }
+    }
+}
+function createRspackBuildTarget(options) {
+    return {
+        executor: '@nx/rspack:rspack',
+        outputs: ['{options.outputPath}'],
+        defaultConfiguration: 'production',
+        options: {
+            outputPath: options.isUsingTsSolutionConfig
+                ? (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'dist')
+                : (0, devkit_1.joinPathFragments)('dist', options.appProjectRoot !== '.'
+                    ? options.appProjectRoot
+                    : options.projectName),
+            index: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/index.html'),
+            baseHref: '/',
+            main: (0, devkit_1.joinPathFragments)(options.appProjectRoot, (0, maybe_js_1.maybeJs)(options, `src/main.tsx`)),
+            tsConfig: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'tsconfig.app.json'),
+            assets: [
+                (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/favicon.ico'),
+                (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/assets'),
+            ],
+            rspackConfig: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'rspack.config.js'),
+            styles: options.styledModule || !options.hasStyles
+                ? []
+                : [
+                    (0, devkit_1.joinPathFragments)(options.appProjectRoot, `src/styles.${options.style}`),
+                ],
+            scripts: [],
+            configurations: {
+                development: {
+                    mode: 'development',
+                },
+                production: {
+                    mode: 'production',
+                    optimization: true,
+                    sourceMap: false,
+                    outputHashing: 'all',
+                    namedChunks: false,
+                    extractLicenses: true,
+                    vendorChunk: false,
+                },
+            },
+        },
+    };
+}
+function createRspackServeTarget(options) {
+    return {
+        executor: '@nx/rspack:dev-server',
+        defaultConfiguration: 'development',
+        options: {
+            buildTarget: `${options.projectName}:build`,
+            hmr: true,
+        },
+        configurations: {
+            development: {
+                buildTarget: `${options.projectName}:build:development`,
+            },
+            production: {
+                buildTarget: `${options.projectName}:build:production`,
+                hmr: false,
+            },
+        },
+    };
 }
 function createBuildTarget(options) {
     return {
@@ -31,9 +135,11 @@ function createBuildTarget(options) {
         defaultConfiguration: 'production',
         options: {
             compiler: options.compiler ?? 'babel',
-            outputPath: (0, devkit_1.joinPathFragments)('dist', options.appProjectRoot != '.'
-                ? options.appProjectRoot
-                : options.projectName),
+            outputPath: options.isUsingTsSolutionConfig
+                ? (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'dist')
+                : (0, devkit_1.joinPathFragments)('dist', options.appProjectRoot !== '.'
+                    ? options.appProjectRoot
+                    : options.projectName),
             index: (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/index.html'),
             baseHref: '/',
             main: (0, devkit_1.joinPathFragments)(options.appProjectRoot, (0, maybe_js_1.maybeJs)(options, `src/main.tsx`)),

package/src/generators/application/lib/add-routing.js

@@ -20,7 +20,7 @@ function addRouting(host, options) {
     }, `src/app/${options.fileName}.tsx`));
     const appFileContent = host.read(appPath, 'utf-8');
     const appSource = tsModule.createSourceFile(appPath, appFileContent, tsModule.ScriptTarget.Latest, true);
-    const changes = (0, devkit_1.applyChangesToString)(appFileContent, (0, ast_utils_1.addInitialRoutes)(appPath, appSource));
+    const changes = (0, devkit_1.applyChangesToString)(appFileContent, (0, ast_utils_1.addInitialRoutes)(appPath, appSource, options.inSourceTests));
     host.write(appPath, changes);
     if (!options.skipPackageJson) {
         return (0, devkit_1.addDependenciesToPackageJson)(host, { 'react-router-dom': versions_1.reactRouterDomVersion }, {});

package/src/generators/application/lib/bundlers/add-rsbuild.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import { NormalizedSchema, Schema } from '../../schema';
+export declare function initRsbuild(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;
+export declare function setupRsbuildConfiguration(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;

package/src/generators/application/lib/bundlers/add-rsbuild.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRsbuild = initRsbuild;
+exports.setupRsbuildConfiguration = setupRsbuildConfiguration;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../../utils/versions");
+const maybe_js_1 = require("../../../../utils/maybe-js");
+async function initRsbuild(tree, options, tasks) {
+    (0, devkit_1.ensurePackage)('@nx/rsbuild', versions_1.nxVersion);
+    const { initGenerator } = await Promise.resolve().then(() => require('@nx/rsbuild/generators'));
+    const initTask = await initGenerator(tree, {
+        skipPackageJson: options.skipPackageJson,
+        addPlugin: true,
+        skipFormat: true,
+    });
+    tasks.push(initTask);
+}
+async function setupRsbuildConfiguration(tree, options, tasks) {
+    (0, devkit_1.ensurePackage)('@nx/rsbuild', versions_1.nxVersion);
+    const { configurationGenerator } = await Promise.resolve().then(() => require('@nx/rsbuild/generators'));
+    const { addBuildPlugin, addCopyAssets, addHtmlTemplatePath, addExperimentalSwcPlugin, versions, } = await Promise.resolve().then(() => require('@nx/rsbuild/config-utils'));
+    const rsbuildTask = await configurationGenerator(tree, {
+        project: options.projectName,
+        entry: (0, maybe_js_1.maybeJs)({
+            js: options.js,
+            useJsx: true,
+        }, `./src/main.tsx`),
+        tsConfig: './tsconfig.app.json',
+        target: 'web',
+        devServerPort: options.devServerPort ?? 4200,
+    });
+    tasks.push(rsbuildTask);
+    const pathToConfigFile = (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'rsbuild.config.ts');
+    const deps = { '@rsbuild/plugin-react': versions.rsbuildPluginReactVersion };
+    addBuildPlugin(tree, pathToConfigFile, '@rsbuild/plugin-react', 'pluginReact', options.style === '@emotion/styled'
+        ? `swcReactOptions: {\n\timportSource: '@emotion/react',\n}`
+        : undefined);
+    if (options.style === 'scss') {
+        addBuildPlugin(tree, pathToConfigFile, '@rsbuild/plugin-sass', 'pluginSass');
+        deps['@rsbuild/plugin-sass'] = versions.rsbuildPluginSassVersion;
+    }
+    else if (options.style === 'less') {
+        addBuildPlugin(tree, pathToConfigFile, '@rsbuild/plugin-less', 'pluginLess');
+        deps['@rsbuild/plugin-less'] = versions.rsbuildPluginLessVersion;
+    }
+    else if (options.style === '@emotion/styled') {
+        deps['@swc/plugin-emotion'] = versions.rsbuildSwcPluginEmotionVersion;
+        addExperimentalSwcPlugin(tree, pathToConfigFile, '@swc/plugin-emotion');
+    }
+    else if (options.style === 'styled-jsx') {
+        deps['@swc/plugin-styled-jsx'] = versions.rsbuildSwcPluginStyledJsxVersion;
+        addExperimentalSwcPlugin(tree, pathToConfigFile, '@swc/plugin-styled-jsx');
+    }
+    else if (options.style === 'styled-components') {
+        deps['@rsbuild/plugin-styled-components'] =
+            versions.rsbuildPluginStyledComponentsVersion;
+        addBuildPlugin(tree, pathToConfigFile, '@rsbuild/plugin-styled-components', 'pluginStyledComponents');
+    }
+    addHtmlTemplatePath(tree, pathToConfigFile, './src/index.html');
+    addCopyAssets(tree, pathToConfigFile, './src/assets');
+    addCopyAssets(tree, pathToConfigFile, './src/favicon.ico');
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, deps));
+}

package/src/generators/application/lib/bundlers/add-rspack.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import { NormalizedSchema, Schema } from '../../schema';
+export declare function initRspack(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;
+export declare function handleStyledJsxForRspack(tasks: any[], tree: Tree, options: NormalizedSchema<Schema>): void;

package/src/generators/application/lib/bundlers/add-rspack.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRspack = initRspack;
+exports.handleStyledJsxForRspack = handleStyledJsxForRspack;
+const devkit_1 = require("@nx/devkit");
+const pc = require("picocolors");
+const versions_1 = require("../../../../utils/versions");
+async function initRspack(tree, options, tasks) {
+    const { rspackInitGenerator } = (0, devkit_1.ensurePackage)('@nx/rspack', versions_1.nxVersion);
+    const rspackInitTask = await rspackInitGenerator(tree, {
+        ...options,
+        skipFormat: true,
+    });
+    tasks.push(rspackInitTask);
+}
+function handleStyledJsxForRspack(tasks, tree, options) {
+    devkit_1.logger.warn(`${pc.bold('styled-jsx')} is not supported by ${pc.bold('Rspack')}. We've added ${pc.bold('babel-loader')} to your project, but using babel will slow down your build.`);
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, { 'babel-loader': versions_1.babelLoaderVersion }));
+    tree.write((0, devkit_1.joinPathFragments)(options.appProjectRoot, 'rspack.config.js'), (0, devkit_1.stripIndents) `
+        const { composePlugins, withNx, withReact } = require('@nx/rspack');
+        module.exports = composePlugins(withNx(), withReact(), (config) => {
+          config.module.rules.push({
+            test: /\\.[jt]sx$/i,
+            use: [
+              {
+                loader: 'babel-loader',
+                options: {
+                  presets: ['@babel/preset-typescript'],
+                  plugins: ['styled-jsx/babel'],
+                },
+              },
+            ],
+          });
+          return config;
+        });
+        `);
+}

package/src/generators/application/lib/bundlers/add-vite.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import { NormalizedSchema, Schema } from '../../schema';
+export declare function setupViteConfiguration(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;
+export declare function setupVitestConfiguration(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;

package/src/generators/application/lib/bundlers/add-vite.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupViteConfiguration = setupViteConfiguration;
+exports.setupVitestConfiguration = setupVitestConfiguration;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../../utils/versions");
+async function setupViteConfiguration(tree, options, tasks) {
+    const { createOrEditViteConfig, viteConfigurationGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+    // We recommend users use `import.meta.env.MODE` and other variables in their code to differentiate between production and development.
+    // See: https://vitejs.dev/guide/env-and-mode.html
+    if (tree.exists((0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/environments'))) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.appProjectRoot, 'src/environments'));
+    }
+    const reactRouterFrameworkConfig = {
+        imports: [`import { reactRouter } from '@react-router/dev/vite'`],
+        plugins: ['!process.env.VITEST && reactRouter()'],
+    };
+    const baseReactConfig = {
+        imports: [
+            options.compiler === 'swc'
+                ? `import react from '@vitejs/plugin-react-swc'`
+                : `import react from '@vitejs/plugin-react'`,
+        ],
+        plugins: ['react()'],
+    };
+    const viteTask = await viteConfigurationGenerator(tree, {
+        uiFramework: 'react',
+        project: options.projectName,
+        newProject: true,
+        includeVitest: options.unitTestRunner === 'vitest',
+        inSourceTests: options.inSourceTests,
+        compiler: options.compiler,
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+        projectType: 'application',
+    });
+    tasks.push(viteTask);
+    createOrEditViteConfig(tree, {
+        project: options.projectName,
+        includeLib: false,
+        includeVitest: options.unitTestRunner === 'vitest',
+        inSourceTests: options.inSourceTests,
+        rollupOptionsExternal: ["'react'", "'react-dom'", "'react/jsx-runtime'"],
+        ...(options.useReactRouter
+            ? reactRouterFrameworkConfig
+            : baseReactConfig),
+    }, false);
+}
+async function setupVitestConfiguration(tree, options, tasks) {
+    const { createOrEditViteConfig, vitestGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+    const vitestTask = await vitestGenerator(tree, {
+        uiFramework: 'react',
+        coverageProvider: 'v8',
+        project: options.projectName,
+        inSourceTests: options.inSourceTests,
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+    });
+    tasks.push(vitestTask);
+    createOrEditViteConfig(tree, {
+        project: options.projectName,
+        includeLib: false,
+        includeVitest: true,
+        inSourceTests: options.inSourceTests,
+        rollupOptionsExternal: ["'react'", "'react-dom'", "'react/jsx-runtime'"],
+        imports: [
+            options.compiler === 'swc'
+                ? `import react from '@vitejs/plugin-react-swc'`
+                : `import react from '@vitejs/plugin-react'`,
+        ],
+        plugins: ['react()'],
+    }, true);
+    if (options.bundler === 'rsbuild') {
+        tree.rename((0, devkit_1.joinPathFragments)(options.appProjectRoot, 'vite.config.ts'), (0, devkit_1.joinPathFragments)(options.appProjectRoot, 'vitest.config.ts'));
+    }
+}

package/src/generators/application/lib/bundlers/add-webpack.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import { Schema, NormalizedSchema } from '../../schema';
+export declare function initWebpack(tree: Tree, options: NormalizedSchema<Schema>, tasks: any[]): Promise<void>;

package/src/generators/application/lib/bundlers/add-webpack.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initWebpack = initWebpack;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../../utils/versions");
+async function initWebpack(tree, options, tasks) {
+    const { webpackInitGenerator } = (0, devkit_1.ensurePackage)('@nx/webpack', versions_1.nxVersion);
+    const webpackInitTask = await webpackInitGenerator(tree, {
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+    });
+    tasks.push(webpackInitTask);
+    if (!options.skipPackageJson) {
+        const { ensureDependencies } = await Promise.resolve().then(() => require('@nx/webpack/src/utils/ensure-dependencies'));
+        tasks.push(ensureDependencies(tree, { uiFramework: 'react' }));
+    }
+}

package/src/generators/application/lib/create-application-files.d.ts

@@ -1,3 +1,64 @@
 import { Tree } from '@nx/devkit';
+import { WithNxOptions } from '@nx/webpack';
+import { WithReactOptions } from '../../../../plugins/with-react';
 import { NormalizedSchema } from '../schema';
+export declare function getDefaultTemplateVariables(host: Tree, options: NormalizedSchema): {
+    typesNodeVersion: string;
+    typesReactDomVersion: string;
+    reactRouterVersion: string;
+    typesReactVersion: string;
+    reactDomVersion: string;
+    reactVersion: string;
+    reactRouterIsBotVersion: string;
+    js: boolean;
+    tmpl: string;
+    offsetFromRoot: string;
+    appTests: string;
+    inSourceVitestTests: string;
+    style: "none" | "styled-components" | "@emotion/styled" | "styled-jsx" | "css" | "scss" | "less";
+    hasStyleFile: boolean;
+    isUsingTsSolutionSetup: boolean;
+    projectName: string;
+    appProjectRoot: string;
+    e2eProjectName: string;
+    e2eProjectRoot: string;
+    importPath: string;
+    parsedTags: string[];
+    fileName: string;
+    styledModule: null | import("../../../..").SupportedStyles;
+    hasStyles: boolean;
+    unitTestRunner: "jest" | "vitest" | "none";
+    addPlugin?: boolean;
+    names: ReturnType<typeof import("@nx/devkit").names>;
+    isUsingTsSolutionConfig?: boolean;
+    directory: string;
+    name: string;
+    skipFormat?: boolean;
+    tags?: string;
+    inSourceTests?: boolean;
+    e2eTestRunner: "cypress" | "playwright" | "none";
+    linter: import("@nx/eslint").Linter | import("@nx/eslint").LinterType;
+    classComponent?: boolean;
+    routing?: boolean;
+    useReactRouter?: boolean;
+    skipNxJson?: boolean;
+    globalCss?: boolean;
+    strict?: boolean;
+    setParserOptionsProject?: boolean;
+    compiler?: "babel" | "swc";
+    remotes?: string[];
+    devServerPort?: number;
+    skipPackageJson?: boolean;
+    rootProject?: boolean;
+    bundler?: "webpack" | "vite" | "rspack" | "rsbuild";
+    minimal?: boolean;
+    nxCloudToken?: string;
+    useTsSolution?: boolean;
+    formatter?: "prettier" | "none";
+    useProjectJson?: boolean;
+    className: string;
+    propertyName: string;
+    constantName: string;
+};
+export declare function createNxRspackPluginOptions(options: NormalizedSchema, rootOffset: string, tsx?: boolean): WithNxOptions & WithReactOptions;
 export declare function createApplicationFiles(host: Tree, options: NormalizedSchema): Promise<void>;