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

package/src/generators/stories/stories.js

@@ -5,17 +5,17 @@ exports.containsComponentDeclaration = containsComponentDeclaration;
 exports.createAllStories = createAllStories;
 exports.storiesGenerator = storiesGenerator;
 const component_story_1 = require("../component-story/component-story");
-const component_cypress_spec_1 = require("../component-cypress-spec/component-cypress-spec");
 const ast_utils_1 = require("../../utils/ast-utils");
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
 const minimatch_1 = require("minimatch");
 const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
 const versions_1 = require("../../utils/versions");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
 let tsModule;
 async function projectRootPath(tree, config) {
     let projectDir;
-    if (config.projectType === 'application') {
+    if ((0, ts_solution_setup_1.getProjectType)(tree, config.root, config.projectType) === 'application') {
         const isNextJs = await isNextJsProject(tree, config);
         if (isNextJs) {
             // Next.js apps
@@ -30,7 +30,10 @@ async function projectRootPath(tree, config) {
         // libs/test-lib/src/lib
         projectDir = 'lib';
     }
-    return (0, devkit_1.joinPathFragments)(config.sourceRoot, projectDir);
+    else {
+        projectDir = '.';
+    }
+    return (0, devkit_1.joinPathFragments)(config.sourceRoot ?? config.root, projectDir);
 }
 function containsComponentDeclaration(tree, componentPath) {
     if (!tsModule) {
@@ -44,7 +47,7 @@ function containsComponentDeclaration(tree, componentPath) {
     return !!((0, ast_utils_1.getComponentNode)(sourceFile) ||
         (0, ast_utils_1.findExportDeclarationsForJsx)(sourceFile)?.length);
 }
-async function createAllStories(tree, projectName, interactionTests, js, projects, projectConfiguration, generateCypressSpecs, cypressProject, ignorePaths) {
+async function createAllStories(tree, projectName, interactionTests, js, projects, projectConfiguration, ignorePaths) {
     const { isTheFileAStory } = await Promise.resolve().then(() => require('@nx/storybook/src/utils/utilities'));
     const { sourceRoot, root } = projectConfiguration;
     let componentPaths = [];
@@ -70,13 +73,8 @@ async function createAllStories(tree, projectName, interactionTests, js, project
             }
         }
     });
-    const e2eProjectName = cypressProject || `${projectName}-e2e`;
-    const e2eProject = projects.get(e2eProjectName);
-    if (generateCypressSpecs && !e2eProject) {
-        devkit_1.logger.info(`There was no e2e project "${e2eProjectName}" found, so cypress specs will not be generated. Pass "--cypressProject" to specify a different e2e project name`);
-    }
     await Promise.all(componentPaths.map(async (componentPath) => {
-        const relativeCmpDir = componentPath.replace((0, path_1.join)(sourceRoot, '/'), '');
+        const relativeCmpDir = componentPath.replace((0, path_1.join)(sourceRoot ?? root, '/'), '');
         if (!containsComponentDeclaration(tree, componentPath)) {
             return;
         }
@@ -86,22 +84,13 @@ async function createAllStories(tree, projectName, interactionTests, js, project
             skipFormat: true,
             interactionTests,
         });
-        if (generateCypressSpecs && e2eProject) {
-            await (0, component_cypress_spec_1.default)(tree, {
-                project: projectName,
-                componentPath: relativeCmpDir,
-                js,
-                cypressProject,
-                skipFormat: true,
-            });
-        }
     }));
 }
 async function storiesGenerator(host, schema) {
     const projects = (0, devkit_1.getProjects)(host);
     const projectConfiguration = projects.get(schema.project);
     schema.interactionTests = schema.interactionTests ?? true;
-    await createAllStories(host, schema.project, schema.interactionTests, schema.js, projects, projectConfiguration, schema.generateCypressSpecs, schema.cypressProject, schema.ignorePaths);
+    await createAllStories(host, schema.project, schema.interactionTests, schema.js, projects, projectConfiguration, schema.ignorePaths);
     const tasks = [];
     if (schema.interactionTests) {
         const { interactionTestsDependencies, addInteractionsInAddons } = (0, devkit_1.ensurePackage)('@nx/storybook', versions_1.nxVersion);

package/src/generators/storybook-configuration/configuration.js

@@ -7,16 +7,10 @@ const stories_1 = require("../stories/stories");
 const devkit_1 = require("@nx/devkit");
 const versions_1 = require("../../utils/versions");
 async function generateStories(host, schema) {
-    // TODO(katerina): Nx 19 -> remove Cypress
-    (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
-    const { getE2eProjectName } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/project-name'));
     const projectConfig = (0, devkit_1.readProjectConfiguration)(host, schema.project);
-    const cypressProject = getE2eProjectName(schema.project, projectConfig.root, schema.cypressDirectory);
     await (0, stories_1.default)(host, {
         project: schema.project,
-        generateCypressSpecs: schema.configureCypress && schema.generateCypressSpecs,
         js: schema.js,
-        cypressProject,
         ignorePaths: schema.ignorePaths,
         skipFormat: true,
         interactionTests: schema.interactionTests ?? true,
@@ -38,9 +32,8 @@ async function storybookConfigurationGeneratorInternal(host, schema) {
     let uiFramework = '@storybook/react-vite';
     const projectConfig = (0, devkit_1.readProjectConfiguration)(host, schema.project);
     if (findWebpackConfig(host, projectConfig.root) ||
-        projectConfig.targets['build']?.executor === '@nx/rollup:rollup' ||
-        projectConfig.targets['build']?.executor === '@nrwl/rollup:rollup' ||
-        projectConfig.targets['build']?.executor === '@nx/expo:build') {
+        projectConfig.targets?.['build']?.executor === '@nx/rollup:rollup' ||
+        projectConfig.targets?.['build']?.executor === '@nx/expo:build') {
         uiFramework = '@storybook/react-webpack5';
     }
     if (uiFramework === '@storybook/react-vite') {
@@ -48,10 +41,8 @@ async function storybookConfigurationGeneratorInternal(host, schema) {
     }
     const installTask = await configurationGenerator(host, {
         project: schema.project,
-        configureCypress: schema.configureCypress,
         js: schema.js,
         linter: schema.linter,
-        cypressDirectory: schema.cypressDirectory,
         tsConfiguration: schema.tsConfiguration ?? true, // default is true
         interactionTests: schema.interactionTests ?? true, // default is true
         configureStaticServe: schema.configureStaticServe,

package/src/generators/storybook-configuration/schema.d.ts

@@ -9,8 +9,5 @@ export interface StorybookConfigureSchema {
   linter?: Linter | LinterType;
   ignorePaths?: string[];
   configureStaticServe?: boolean;
-  configureCypress?: boolean;
-  generateCypressSpecs?: boolean;
-  cypressDirectory?: string;
   addPlugin?: boolean;
 }

package/src/generators/storybook-configuration/schema.json

@@ -26,11 +26,6 @@
       "alias": ["configureTestRunner"],
       "default": true
     },
-    "configureCypress": {
-      "type": "boolean",
-      "description": "Run the cypress-configure generator.",
-      "x-deprecated": "Use interactionTests instead. This option will be removed in v20."
-    },
     "generateStories": {
       "type": "boolean",
       "description": "Automatically generate `*.stories.ts` files for components declared in this project?",
@@ -38,11 +33,6 @@
       "default": true,
       "x-priority": "important"
     },
-    "generateCypressSpecs": {
-      "type": "boolean",
-      "description": "Automatically generate test files in the Cypress E2E app generated by the `cypress-configure` generator.",
-      "x-deprecated": "Use interactionTests instead. This option will be removed in v20."
-    },
     "configureStaticServe": {
       "type": "boolean",
       "description": "Specifies whether to configure a static file server target for serving storybook. Helpful for speeding up CI build/test times.",
@@ -50,11 +40,6 @@
       "default": true,
       "x-priority": "important"
     },
-    "cypressDirectory": {
-      "type": "string",
-      "description": "A directory where the Cypress project will be placed. Placed at the root by default.",
-      "x-deprecated": "Use interactionTests instead. This option will be removed in v20."
-    },
     "js": {
       "type": "boolean",
       "description": "Generate JavaScript story files rather than TypeScript story files.",

package/src/migrations/update-18-0-0/add-mf-env-var-to-target-defaults.js

@@ -4,10 +4,11 @@ exports.default = default_1;
 const devkit_1 = require("@nx/devkit");
 const add_mf_env_to_inputs_1 = require("../../utils/add-mf-env-to-inputs");
 async function default_1(tree) {
-    if (!hasModuleFederationProject(tree)) {
+    const bundler = hasModuleFederationProject(tree);
+    if (!bundler) {
         return;
     }
-    (0, add_mf_env_to_inputs_1.addMfEnvToTargetDefaultInputs)(tree);
+    (0, add_mf_env_to_inputs_1.addMfEnvToTargetDefaultInputs)(tree, bundler);
     await (0, devkit_1.formatFiles)(tree);
 }
 function hasModuleFederationProject(tree) {
@@ -15,10 +16,14 @@ function hasModuleFederationProject(tree) {
     for (const project of projects.values()) {
         const targets = project.targets || {};
         for (const [_, target] of Object.entries(targets)) {
-            if (target.executor === '@nx/webpack:webpack' &&
-                (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'module-federation.config.ts')) ||
-                    tree.exists((0, devkit_1.joinPathFragments)(project.root, 'module-federation.config.js')))) {
-                return true;
+            if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'module-federation.config.ts')) ||
+                tree.exists((0, devkit_1.joinPathFragments)(project.root, 'module-federation.config.js'))) {
+                if (target.executor === '@nx/webpack:webpack') {
+                    return 'webpack';
+                }
+                else if (target.executor === '@nx/rspack:rspack') {
+                    return 'rspack';
+                }
             }
         }
     }

package/src/migrations/update-20-2-0/migrate-mf-imports-to-new-package.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function migrateMfImportsToNewPackage(tree: Tree): Promise<void>;

package/src/migrations/update-20-2-0/migrate-mf-imports-to-new-package.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateMfImportsToNewPackage;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const MF_IMPORT_TO_UPDATE = 'ModuleFederationConfig';
+const MF_CONFIG_IMPORT_SELECTOR = `ImportDeclaration:has(StringLiteral[value=@nx/webpack]):has(Identifier[name=ModuleFederationConfig]),ImportDeclaration:has(StringLiteral[value=@nx/rspack/module-federation]):has(Identifier[name=ModuleFederationConfig])`;
+const IMPORT_TOKENS_SELECTOR = `ImportClause ImportSpecifier`;
+const MF_CONFIG_IMPORT_SPECIFIER_SELECTOR = `ImportClause ImportSpecifier > Identifier[name=ModuleFederationConfig]`;
+const WEBPACK_IMPORT_SELECTOR = `ImportDeclaration > StringLiteral[value=@nx/webpack]`;
+const RSPACK_IMPORT_SELECTOR = `ImportDeclaration > StringLiteral[value=@nx/rspack/module-federation]`;
+async function migrateMfImportsToNewPackage(tree) {
+    const rootsToCheck = new Set();
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    for (const [project, dependencies] of Object.entries(graph.dependencies)) {
+        if (!graph.nodes[project]) {
+            continue;
+        }
+        const usesNxWebpackOrRspack = dependencies.some((dep) => dep.target === 'npm:@nx/webpack' || dep.target === 'npm:@nx/rspack');
+        if (usesNxWebpackOrRspack) {
+            const root = graph.nodes[project].data.root;
+            rootsToCheck.add(root);
+        }
+    }
+    for (const root of rootsToCheck) {
+        (0, devkit_2.visitNotIgnoredFiles)(tree, root, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes(MF_IMPORT_TO_UPDATE)) {
+                return;
+            }
+            const ast = tsquery_1.tsquery.ast(contents);
+            const importNodes = (0, tsquery_1.tsquery)(ast, MF_CONFIG_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            const importNode = importNodes[0];
+            const importSpecifiers = (0, tsquery_1.tsquery)(importNode, IMPORT_TOKENS_SELECTOR);
+            if (importSpecifiers.length > 1) {
+                const mfConfigImportSpecifierNode = (0, tsquery_1.tsquery)(importNode, MF_CONFIG_IMPORT_SPECIFIER_SELECTOR)[0];
+                const end = contents.charAt(mfConfigImportSpecifierNode.getEnd()) === ','
+                    ? mfConfigImportSpecifierNode.getEnd() + 1
+                    : mfConfigImportSpecifierNode.getEnd();
+                contents = `import { ${MF_IMPORT_TO_UPDATE} } from '@nx/module-federation';
+      ${contents.slice(0, mfConfigImportSpecifierNode.getStart())}${contents.slice(end)}`;
+            }
+            else {
+                const nxWebpackImportStringNodes = (0, tsquery_1.tsquery)(importNode, WEBPACK_IMPORT_SELECTOR);
+                const nxRspackImportStringNodes = (0, tsquery_1.tsquery)(importNode, RSPACK_IMPORT_SELECTOR);
+                if (nxWebpackImportStringNodes.length === 0 &&
+                    nxRspackImportStringNodes.length === 0) {
+                    return;
+                }
+                const bundlerImportStringNode = nxWebpackImportStringNodes.length
+                    ? nxWebpackImportStringNodes[0]
+                    : nxRspackImportStringNodes[0];
+                contents = `${contents.slice(0, bundlerImportStringNode.getStart())}'@nx/module-federation'${contents.slice(bundlerImportStringNode.getEnd())}`;
+            }
+            tree.write(filePath, contents);
+        });
+    }
+    await (0, devkit_2.formatFiles)(tree);
+}

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateWithMfImport(tree: Tree): Promise<void>;

package/src/migrations/update-20-2-0/migrate-with-mf-import-to-new-package.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateWithMfImport;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const versions_1 = require("../../utils/versions");
+const NX_RSPACK_MODULE_FEDERATION_IMPORT_SELECTOR = 'ImportDeclaration > StringLiteral[value=@nx/react/module-federation], VariableStatement CallExpression:has(Identifier[name=require]) > StringLiteral[value=@nx/react/module-federation]';
+const NEW_IMPORT_PATH = `'@nx/module-federation/webpack'`;
+async function migrateWithMfImport(tree) {
+    const projects = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/react:module-federation-dev-server', (options, project, target) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+        projects.add(projectConfig.root);
+    });
+    for (const projectRoot of projects) {
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectRoot, (filePath) => {
+            if (!filePath.endsWith('.ts') && !filePath.endsWith('.js')) {
+                return;
+            }
+            let contents = tree.read(filePath, 'utf-8');
+            if (!contents.includes('@nx/react/module-federation')) {
+                return;
+            }
+            const ast = tsquery_1.tsquery.ast(contents);
+            const importNodes = (0, tsquery_1.tsquery)(ast, NX_RSPACK_MODULE_FEDERATION_IMPORT_SELECTOR);
+            if (importNodes.length === 0) {
+                return;
+            }
+            const importPathNode = importNodes[0];
+            contents = `${contents.slice(0, importPathNode.getStart())}${NEW_IMPORT_PATH}${contents.slice(importPathNode.getEnd())}`;
+            tree.write(filePath, contents);
+        });
+    }
+    if (projects.size !== 0) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/module-federation': versions_1.nxVersion,
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function ensureMfPackage(tree: Tree): Promise<void>;

package/src/migrations/update-20-3-0/ensure-nx-module-federation-package.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ensureMfPackage;
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+const versions_1 = require("../../utils/versions");
+async function ensureMfPackage(tree) {
+    const projects = new Set();
+    (0, executor_options_utils_1.forEachExecutorOptions)(tree, '@nx/react:module-federation-dev-server', (options, project, target) => {
+        const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, project);
+        projects.add(projectConfig.root);
+    });
+    if (projects.size !== 0) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@nx/module-federation': versions_1.nxVersion,
+        });
+    }
+}

package/src/migrations/update-21-0-0/update-babel-loose.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function updateBabelLoose(tree: Tree): Promise<void>;

package/src/migrations/update-21-0-0/update-babel-loose.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = updateBabelLoose;
+const devkit_1 = require("@nx/devkit");
+async function updateBabelLoose(tree) {
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '', (path) => {
+        if (!path.endsWith('.babelrc'))
+            return;
+        try {
+            (0, devkit_1.updateJson)(tree, path, (babelConfig) => {
+                if (!Array.isArray(babelConfig.presets))
+                    return babelConfig;
+                const ourPreset = babelConfig.presets.find((p) => Array.isArray(p) && p[0] === '@nx/react/babel');
+                if (!ourPreset || !ourPreset[1])
+                    return babelConfig;
+                const options = ourPreset[1];
+                if (options['classProperties']?.loose !== undefined) {
+                    options.loose = options['classProperties'].loose;
+                    delete options['classProperties'];
+                }
+                return babelConfig;
+            });
+        }
+        catch {
+            // Skip if JSON does not parse for whatever reason
+            return;
+        }
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/plugins/router-plugin.d.ts

@@ -0,0 +1,10 @@
+import { type CreateNodesV2 } from '@nx/devkit';
+export interface ReactRouterPluginOptions {
+    buildTargetName?: string;
+    devTargetName?: string;
+    startTargetName?: string;
+    typecheckTargetName?: string;
+    buildDepsTargetName?: string;
+    watchDepsTargetName?: string;
+}
+export declare const createNodesV2: CreateNodesV2<ReactRouterPluginOptions>;

package/src/plugins/router-plugin.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const js_1 = require("@nx/js");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const util_1 = require("@nx/js/src/plugins/typescript/util");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const pmCommand = (0, devkit_1.getPackageManagerCommand)();
+const reactRouterConfigBlob = '**/react-router.config.{ts,js,cjs,cts,mjs,mts}';
+function readTargetsCache(cachePath) {
+    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, fs_1.existsSync)(cachePath)
+        ? (0, devkit_1.readJsonFile)(cachePath)
+        : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+exports.createNodesV2 = [
+    reactRouterConfigBlob,
+    async (configFiles, options, context) => {
+        const optionsHash = (0, devkit_internals_1.hashObject)(options);
+        const normalizedOptions = normalizeOptions(options);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `react-router-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        const { roots: projectRoots, configFiles: validConfigFiles } = configFiles.reduce((acc, configFile) => {
+            const potentialRoot = (0, path_1.dirname)(configFile);
+            if (checkIfConfigFileShouldBeProject(potentialRoot, context)) {
+                acc.roots.push(potentialRoot);
+                acc.configFiles.push(configFile);
+            }
+            return acc;
+        }, {
+            roots: [],
+            configFiles: [],
+        });
+        const lockfile = (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((_) => [lockfile]));
+        try {
+            return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
+                const projectRoot = (0, path_1.dirname)(configFile);
+                const siblingFiles = (0, fs_1.readdirSync)((0, devkit_1.joinPathFragments)(context.workspaceRoot, projectRoot));
+                const hash = hashes[idx] + configFile;
+                const { projectType, metadata, targets } = (targetsCache[hash] ??=
+                    await buildReactRouterTargets(configFile, projectRoot, normalizedOptions, context, siblingFiles, isUsingTsSolutionSetup));
+                const project = {
+                    root: projectRoot,
+                    targets,
+                    metadata,
+                };
+                if (project.targets[normalizedOptions.buildTargetName]) {
+                    project.projectType = projectType;
+                }
+                return {
+                    projects: {
+                        [projectRoot]: project,
+                    },
+                };
+            }, validConfigFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
+async function buildReactRouterTargets(configFilePath, projectRoot, options, context, siblingFiles, isUsingTsSolutionSetup) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const configPath = (0, path_1.join)(context.workspaceRoot, configFilePath);
+    if (require.cache[configPath])
+        (0, config_utils_1.clearRequireCache)();
+    const reactRouterConfig = await (0, config_utils_1.loadConfigFile)(configPath);
+    const isLibMode = reactRouterConfig?.ssr !== undefined && reactRouterConfig.ssr === false;
+    const { buildDirectory, serverBuildPath } = await getBuildPaths(reactRouterConfig, isLibMode);
+    const targets = {};
+    targets[options.buildTargetName] = await getBuildTargetConfig(options.buildTargetName, projectRoot, buildDirectory, serverBuildPath, namedInputs, isUsingTsSolutionSetup);
+    targets[options.devTargetName] = await devTarget(projectRoot, isUsingTsSolutionSetup);
+    if (serverBuildPath) {
+        targets[options.startTargetName] = await startTarget(projectRoot, serverBuildPath, options.buildTargetName, isUsingTsSolutionSetup);
+    }
+    targets[options.typecheckTargetName] = await typecheckTarget(projectRoot, options.typecheckTargetName, namedInputs, siblingFiles, isUsingTsSolutionSetup);
+    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmCommand);
+    const metadata = {};
+    return {
+        targets,
+        metadata,
+        projectType: isLibMode ? 'library' : 'application',
+    };
+}
+async function getBuildTargetConfig(buildTargetName, projectRoot, buildDirectory, serverBuildDirectory, namedInputs, isUsingTsSolutionSetup) {
+    const basePath = projectRoot === '.'
+        ? `{workspaceRoot}`
+        : (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, projectRoot);
+    const outputs = [
+        (0, devkit_1.joinPathFragments)(basePath, buildDirectory),
+        ...(serverBuildDirectory
+            ? [(0, devkit_1.joinPathFragments)(basePath, serverBuildDirectory)]
+            : []),
+    ];
+    const buildTarget = {
+        cache: true,
+        dependsOn: [`^${buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+            { externalDependencies: ['@react-router/dev'] },
+        ],
+        outputs,
+        command: 'react-router build',
+        options: { cwd: projectRoot },
+    };
+    if (isUsingTsSolutionSetup) {
+        buildTarget.syncGenerators = ['@nx/js:typescript-sync'];
+    }
+    return buildTarget;
+}
+async function getBuildPaths(reactRouterConfig, isLibMode) {
+    return {
+        buildDirectory: reactRouterConfig?.buildDirectory ?? 'build/client',
+        ...(isLibMode
+            ? undefined
+            : {
+                serverBuildPath: reactRouterConfig?.buildDirectory
+                    ? (0, path_1.join)((0, path_1.dirname)(reactRouterConfig.buildDirectory), `server`)
+                    : 'build/server',
+            }),
+    };
+}
+async function devTarget(projectRoot, isUsingTsSolutionSetup) {
+    const devTarget = {
+        continuous: true,
+        command: 'react-router dev',
+        options: { cwd: projectRoot },
+    };
+    if (isUsingTsSolutionSetup) {
+        devTarget.syncGenerators = ['@nx/js:typescript-sync'];
+    }
+    return devTarget;
+}
+async function startTarget(projectRoot, serverBuildPath, buildTargetName, isUsingTsSolutionSetup) {
+    const serverPath = serverBuildPath === 'build/server'
+        ? `${serverBuildPath}/index.js`
+        : serverBuildPath;
+    const startTarget = {
+        continuous: true,
+        dependsOn: [buildTargetName],
+        command: `react-router-serve ${serverPath}`,
+        options: { cwd: projectRoot },
+    };
+    if (isUsingTsSolutionSetup) {
+        startTarget.syncGenerators = ['@nx/js:typescript-sync'];
+    }
+    return startTarget;
+}
+async function typecheckTarget(projectRoot, typecheckTargetName, namedInputs, siblingFiles, isUsingTsSolutionSetup) {
+    const hasTsConfigAppJson = siblingFiles.includes('tsconfig.app.json');
+    const typecheckTarget = {
+        cache: true,
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+            { externalDependencies: ['typescript'] },
+        ],
+        command: isUsingTsSolutionSetup
+            ? `tsc --build --emitDeclarationOnly`
+            : `tsc${hasTsConfigAppJson ? ` -p tsconfig.app.json` : ``} --noEmit`,
+        options: {
+            cwd: projectRoot,
+        },
+        metadata: {
+            description: `Runs type-checking for the project.`,
+            technologies: ['typescript'],
+            help: {
+                command: isUsingTsSolutionSetup
+                    ? `${pmCommand.exec} tsc --build --help`
+                    : `${pmCommand.exec} tsc${hasTsConfigAppJson ? ` -p tsconfig.app.json` : ``} --help`,
+                example: isUsingTsSolutionSetup
+                    ? { args: ['--force'] }
+                    : { options: { noEmit: true } },
+            },
+        },
+    };
+    if (isUsingTsSolutionSetup) {
+        typecheckTarget.dependsOn = [`^${typecheckTargetName}`];
+        typecheckTarget.syncGenerators = ['@nx/js:typescript-sync'];
+    }
+    return typecheckTarget;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.devTargetName ??= 'dev';
+    options.startTargetName ??= 'start';
+    options.typecheckTargetName ??= 'typecheck';
+    return options;
+}
+function checkIfConfigFileShouldBeProject(projectRoot, context) {
+    // Do not create a project if package.json and project.json isn't there.
+    const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+    return hasRequiredConfigs(siblingFiles);
+}
+function hasRequiredConfigs(files) {
+    const lowerFiles = files.map((file) => file.toLowerCase());
+    // Check if vite.config.{ext} is present
+    const hasViteConfig = lowerFiles.some((file) => {
+        const parts = file.split('.');
+        return parts[0] === 'vite' && parts[1] === 'config' && parts.length > 2;
+    });
+    if (!hasViteConfig)
+        return false;
+    const hasProjectOrPackageJson = lowerFiles.includes('project.json') || lowerFiles.includes('package.json');
+    return hasProjectOrPackageJson;
+}

package/src/rules/update-module-federation-project.d.ts

@@ -7,4 +7,5 @@ export declare function updateModuleFederationProject(host: Tree, options: {
     typescriptConfiguration?: boolean;
     dynamic?: boolean;
     bundler?: 'rspack' | 'webpack';
-}): void;
+    ssr?: boolean;
+}, isHost?: boolean): void;