@nx/angular 23.0.0-pr.35413.460eeef → 23.0.0-rc.0

package/dist/src/generators/ngrx-root-store/lib/add-imports.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImportsToModule = addImportsToModule;
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
+let tsModule;
+function addRootStoreImport(tree, isParentStandalone, sourceFile, parentPath, provideRootStore, storeForRoot) {
+    if (isParentStandalone) {
+        if (tree.read(parentPath, 'utf-8').includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideRootStore);
+        }
+        else {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideRootStore);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeForRoot);
+    }
+    return sourceFile;
+}
+function addRootEffectsImport(tree, isParentStandalone, sourceFile, parentPath, provideRootEffects, effectsForEmptyRoot) {
+    if (isParentStandalone) {
+        if (tree.read(parentPath, 'utf-8').includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideRootEffects);
+        }
+        else {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideRootEffects);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, effectsForEmptyRoot);
+    }
+    return sourceFile;
+}
+function addRouterStoreImport(tree, sourceFile, addImport, parentPath, storeRouterModule) {
+    sourceFile = addImport(sourceFile, 'StoreRouterConnectingModule', '@ngrx/router-store');
+    return (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeRouterModule);
+}
+function addStoreDevTools(tree, sourceFile, parentPath, isParentStandalone, addImport) {
+    sourceFile = addImport(sourceFile, 'isDevMode', '@angular/core');
+    if (isParentStandalone) {
+        sourceFile = addImport(sourceFile, 'provideStoreDevtools', '@ngrx/store-devtools');
+        const provideStoreDevTools = 'provideStoreDevtools({ logOnly: !isDevMode() })';
+        if (tree.read(parentPath, 'utf-8').includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideStoreDevTools);
+        }
+        else {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideStoreDevTools);
+        }
+    }
+    else {
+        sourceFile = addImport(sourceFile, 'StoreDevtoolsModule', '@ngrx/store-devtools');
+        const storeDevToolsModule = 'StoreDevtoolsModule.instrument({ logOnly: !isDevMode() })';
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeDevToolsModule);
+    }
+    return sourceFile;
+}
+function addImportsToModule(tree, options) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const parentPath = options.parent;
+    const sourceText = tree.read(parentPath, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(parentPath, sourceText, tsModule.ScriptTarget.Latest, true);
+    const isParentStandalone = !sourceText.includes('@NgModule');
+    const addImport = (source, symbolName, fileName, isDefault = false) => {
+        return (0, js_1.insertImport)(tree, source, parentPath, symbolName, fileName, isDefault);
+    };
+    const storeMetaReducers = `metaReducers: []`;
+    const storeForRoot = `StoreModule.forRoot({}, {
+      ${storeMetaReducers},
+      runtimeChecks: {
+        strictActionImmutability: true,
+        strictStateImmutability: true
+      }
+    })`;
+    const effectsForEmptyRoot = `EffectsModule.forRoot([])`;
+    const storeRouterModule = 'StoreRouterConnectingModule.forRoot()';
+    const provideRootStore = `provideStore()`;
+    const provideRootEffects = `provideEffects()`;
+    if (isParentStandalone) {
+        sourceFile = addImport(sourceFile, 'provideStore', '@ngrx/store');
+        sourceFile = addImport(sourceFile, 'provideEffects', '@ngrx/effects');
+    }
+    else {
+        sourceFile = addImport(sourceFile, 'StoreModule', '@ngrx/store');
+        sourceFile = addImport(sourceFile, 'EffectsModule', '@ngrx/effects');
+    }
+    sourceFile = addRootEffectsImport(tree, isParentStandalone, sourceFile, parentPath, provideRootEffects, effectsForEmptyRoot);
+    if (options.addDevTools) {
+        sourceFile = addStoreDevTools(tree, sourceFile, parentPath, isParentStandalone, addImport);
+    }
+    sourceFile = addRootStoreImport(tree, isParentStandalone, sourceFile, parentPath, provideRootStore, storeForRoot);
+    // this is just a heuristic
+    const hasRouter = sourceText.indexOf('RouterModule') > -1;
+    if (hasRouter && !isParentStandalone) {
+        sourceFile = addRouterStoreImport(tree, sourceFile, addImport, parentPath, storeRouterModule);
+    }
+}

package/dist/src/generators/ngrx-root-store/lib/add-ngrx-to-package-json.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { NormalizedNgRxRootStoreGeneratorOptions } from './normalize-options';
+export declare function addNgRxToPackageJson(tree: Tree, options: NormalizedNgRxRootStoreGeneratorOptions): GeneratorCallback;

package/dist/src/generators/ngrx-root-store/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './add-imports';
+export * from './add-ngrx-to-package-json';
+export * from './normalize-options';
+export * from './validate-options';

package/dist/src/generators/ngrx-root-store/lib/normalize-options.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export type NormalizedNgRxRootStoreGeneratorOptions = Schema & {
+    parent: string;
+    rxjsVersion: string;
+};
+export declare function normalizeOptions(tree: Tree, options: Schema): NormalizedNgRxRootStoreGeneratorOptions;

package/dist/src/generators/ngrx-root-store/lib/normalize-options.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const internal_2 = require("@nx/js/internal");
+function normalizeOptions(tree, options) {
+    let rxjsVersion;
+    try {
+        const rxjsVersionFromPackageJson = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'rxjs', 'package.json', ['dependencies']);
+        rxjsVersion = (0, internal_1.checkAndCleanWithSemver)(tree, 'rxjs', rxjsVersionFromPackageJson);
+    }
+    catch {
+        rxjsVersion = (0, internal_1.checkAndCleanWithSemver)(tree, 'rxjs', versions_1.rxjsVersion);
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const isStandalone = (0, ast_utils_1.isNgStandaloneApp)(tree, options.project);
+    const sourceRoot = (0, internal_2.getProjectSourceRoot)(project, tree);
+    const appConfigPath = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.config.ts');
+    let appMainPath = project.targets.build.options.main ?? project.targets.build.options.browser;
+    if (!appMainPath) {
+        appMainPath = (0, devkit_1.joinPathFragments)(sourceRoot, 'main.ts');
+    }
+    /** If NgModule App
+     * -> Use App Module
+     * If Standalone
+     * -> Check Config File exists (v16+)
+     * --> If so, use that
+     * --> If not, use main.ts
+     */
+    let ngModulePath = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app.module.ts');
+    if (!tree.exists(ngModulePath)) {
+        ngModulePath = (0, devkit_1.joinPathFragments)(sourceRoot, 'app/app-module.ts');
+    }
+    const parent = !isStandalone && tree.exists(ngModulePath)
+        ? ngModulePath
+        : tree.exists(appConfigPath)
+            ? appConfigPath
+            : appMainPath;
+    options.directory = options.directory ?? '+state';
+    return {
+        ...options,
+        parent,
+        directory: (0, devkit_1.names)(options.directory).fileName,
+        rxjsVersion,
+    };
+}

package/dist/src/generators/ngrx-root-store/lib/validate-options.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+export declare function validateOptions(tree: Tree, options: Schema): void;

package/dist/src/generators/ngrx-root-store/ngrx-root-store.d.ts

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

package/dist/src/generators/ngrx-root-store/ngrx-root-store.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngrxRootStoreGenerator = ngrxRootStoreGenerator;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const lib_1 = require("./lib");
+const ngrx_feature_store_1 = tslib_1.__importDefault(require("../ngrx-feature-store/ngrx-feature-store"));
+async function ngrxRootStoreGenerator(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, lib_1.validateOptions)(tree, schema);
+    const options = (0, lib_1.normalizeOptions)(tree, schema);
+    if (!options.skipImport) {
+        (0, lib_1.addImportsToModule)(tree, options);
+    }
+    if (!options.minimal) {
+        await (0, ngrx_feature_store_1.default)(tree, {
+            name: options.name,
+            parent: options.parent,
+            directory: options.directory,
+            minimal: false,
+            facade: options.facade,
+            barrels: false,
+            skipImport: false,
+            skipPackageJson: true,
+            skipFormat: true,
+        });
+    }
+    let packageInstallationTask = () => { };
+    if (!options.skipPackageJson) {
+        packageInstallationTask = (0, lib_1.addNgRxToPackageJson)(tree, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return packageInstallationTask;
+}
+exports.default = ngrxRootStoreGenerator;

package/dist/src/generators/pipe/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './normalize-options';

package/dist/src/generators/pipe/lib/normalize-options.d.ts

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

package/dist/src/generators/pipe/lib/normalize-options.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const validations_1 = require("../../utils/validations");
+const version_utils_1 = require("../../utils/version-utils");
+async function normalizeOptions(tree, options) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    options.typeSeparator ??= angularMajorVersion < 20 ? '.' : '-';
+    const { artifactName: name, directory, fileName, filePath, project: projectName, } = await (0, internal_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        name: options.name,
+        path: options.path,
+        suffix: 'pipe',
+        suffixSeparator: options.typeSeparator,
+        allowedFileExtensions: ['ts'],
+        fileExtension: 'ts',
+    });
+    const { className } = (0, devkit_1.names)(name);
+    const { className: suffixClassName } = (0, devkit_1.names)('pipe');
+    const symbolName = `${className}${suffixClassName}`;
+    (0, validations_1.validateClassName)(symbolName);
+    return {
+        ...options,
+        projectName,
+        name,
+        directory,
+        fileName,
+        filePath,
+        symbolName,
+        standalone: options.standalone ?? true,
+    };
+}

package/dist/src/generators/pipe/pipe.d.ts

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

package/dist/src/generators/pipe/pipe.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipeGenerator = pipeGenerator;
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const utils_1 = require("../utils");
+const lib_1 = require("./lib");
+async function pipeGenerator(tree, rawOptions) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    const options = await (0, lib_1.normalizeOptions)(tree, rawOptions);
+    const pipeNames = (0, devkit_1.names)(options.name);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, 'files'), options.directory, {
+        symbolName: options.symbolName,
+        fileName: options.fileName,
+        selector: pipeNames.propertyName,
+        standalone: options.standalone,
+        tpl: '',
+    });
+    if (options.skipTests) {
+        const pathToSpecFile = (0, devkit_1.joinPathFragments)(options.directory, `${options.fileName}.spec.ts`);
+        tree.delete(pathToSpecFile);
+    }
+    if (!options.skipImport && !options.standalone) {
+        const modulePath = (0, utils_1.findModule)(tree, options.directory, options.module);
+        (0, utils_1.addToNgModule)(tree, options.directory, modulePath, options.name, options.symbolName, options.fileName, 'declarations', true, options.export);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+}
+exports.default = pipeGenerator;

package/dist/src/generators/remote/lib/find-next-available-port.d.ts

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

package/dist/src/generators/remote/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './find-next-available-port';
+export * from './update-ssr-setup';
+export * from './validate-options';

package/dist/src/generators/remote/lib/update-ssr-setup.d.ts

@@ -0,0 +1,9 @@
+import type { Tree } from '@nx/devkit';
+export declare function updateSsrSetup(tree: Tree, { appName, port, standalone, typescriptConfiguration, zoneless, skipPackageJson, }: {
+    appName: string;
+    port: number;
+    standalone: boolean;
+    typescriptConfiguration: boolean;
+    zoneless: boolean;
+    skipPackageJson?: boolean;
+}): Promise<import("@nx/devkit").GeneratorCallback>;

package/dist/src/generators/remote/lib/update-ssr-setup.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSsrSetup = updateSsrSetup;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const path_1 = require("path");
+const semver_1 = require("semver");
+const versions_1 = require("../../../utils/versions");
+const artifact_types_1 = require("../../utils/artifact-types");
+const version_utils_1 = require("../../utils/version-utils");
+async function updateSsrSetup(tree, { appName, port, standalone, typescriptConfiguration, zoneless, skipPackageJson, }) {
+    const { major: angularMajorVersion, version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    let project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    const sourceRoot = (0, internal_1.getProjectSourceRoot)(project, tree);
+    tree.rename((0, devkit_1.joinPathFragments)(sourceRoot, 'main.server.ts'), (0, devkit_1.joinPathFragments)(sourceRoot, 'bootstrap.server.ts'));
+    const pathToServerEntry = (0, devkit_1.joinPathFragments)(sourceRoot, 'server.ts');
+    tree.write(pathToServerEntry, `import('./main.server');`);
+    const browserBundleOutput = project.targets.build.options.outputPath;
+    const serverBundleOutput = project.targets.build.options.outputPath.replace(/\/browser$/, '/server');
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files/common'), project.root, {
+        appName,
+        browserBundleOutput,
+        serverBundleOutput,
+        standalone,
+        zoneless,
+        useDefaultImport: angularMajorVersion >= 21,
+        angularMajorVersion,
+        tmpl: '',
+    });
+    const pathToTemplateFiles = typescriptConfiguration ? 'base-ts' : 'base';
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, `../files/${pathToTemplateFiles}`), project.root, {
+        tmpl: '',
+    });
+    if (standalone) {
+        const componentType = (0, artifact_types_1.getComponentType)(tree);
+        const componentFileSuffix = componentType ? `.${componentType}` : '';
+        const useBootstrapContext = 
+        // https://github.com/angular/angular-cli/releases/tag/20.3.0
+        (0, semver_1.gte)(angularVersion, '20.3.0') ||
+            // https://github.com/angular/angular-cli/releases/tag/19.2.16
+            (angularMajorVersion === 19 && (0, semver_1.gte)(angularVersion, '19.2.16'));
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/standalone'), project.root, {
+            appName,
+            standalone,
+            componentType: componentType ? (0, devkit_1.names)(componentType).className : '',
+            componentFileSuffix,
+            useBootstrapContext,
+            tmpl: '',
+        });
+    }
+    // update project.json
+    project = (0, devkit_1.readProjectConfiguration)(tree, appName);
+    project.targets.server.executor = '@nx/angular:webpack-server';
+    project.targets.server.options.customWebpackConfig = {
+        path: (0, devkit_1.joinPathFragments)(project.root, `webpack.server.config.${typescriptConfiguration ? 'ts' : 'js'}`),
+    };
+    if (project.targets.server.configurations &&
+        project.targets.server.configurations.development) {
+        if ('vendorChunk' in project.targets.server.configurations.development) {
+            delete project.targets.server.configurations.development.vendorChunk;
+        }
+    }
+    project.targets['serve-ssr'].options = {
+        ...(project.targets['serve-ssr'].options ?? {}),
+        port,
+    };
+    project.targets['static-server'] = {
+        dependsOn: ['build', 'server'],
+        executor: 'nx:run-commands',
+        options: {
+            command: `PORT=${port} node ${(0, devkit_1.joinPathFragments)(project.targets.server.options.outputPath, 'main.js')}`,
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(tree, appName, project);
+    if (!skipPackageJson) {
+        return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+            cors: versions_1.corsVersion,
+            '@module-federation/node': versions_1.moduleFederationNodeVersion,
+        }, {
+            '@types/cors': versions_1.typesCorsVersion,
+        });
+    }
+    return () => { };
+}

package/dist/src/generators/remote/lib/validate-options.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function validateOptions(tree: Tree, options: Schema): void;

package/dist/src/generators/remote/remote.d.ts

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

package/dist/src/generators/remote/remote.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remote = remote;
+const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const internal_2 = require("@nx/js/internal");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const test_runners_1 = require("../../utils/test-runners");
+const application_1 = require("../application/application");
+const convert_to_rspack_1 = tslib_1.__importDefault(require("../convert-to-rspack/convert-to-rspack"));
+const setup_mf_1 = require("../setup-mf/setup-mf");
+const add_mf_env_to_inputs_1 = require("../utils/add-mf-env-to-inputs");
+const assert_mf_utils_1 = require("../utils/assert-mf-utils");
+const validations_1 = require("../utils/validations");
+const version_utils_1 = require("../utils/version-utils");
+const lib_1 = require("./lib");
+async function remote(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, validations_1.assertNotUsingTsSolutionSetup)(tree, 'remote');
+    (0, lib_1.validateOptions)(tree, schema);
+    // TODO: Replace with Rspack when confidence is high enough
+    schema.bundler ??= 'webpack';
+    const isRspack = schema.bundler === 'rspack';
+    (0, assert_mf_utils_1.assertRspackIsCSR)(schema.bundler, schema.ssr ?? false);
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    schema.zoneless ??= angularMajorVersion >= 21 ? true : false;
+    const { typescriptConfiguration = true, ...options } = schema;
+    options.standalone = options.standalone ?? true;
+    const projects = (0, devkit_1.getProjects)(tree);
+    if (options.host && !projects.has(options.host)) {
+        throw new Error(`The name of the application to be used as the host app does not exist. (${options.host})`);
+    }
+    await (0, internal_1.ensureRootProjectName)(options, 'application');
+    const { projectName: remoteProjectName } = await (0, internal_1.determineProjectNameAndRootOptions)(tree, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+    });
+    const REMOTE_NAME_REGEX = '^[a-zA-Z_$][a-zA-Z_$0-9]*$';
+    const remoteNameRegex = new RegExp(REMOTE_NAME_REGEX);
+    if (!remoteNameRegex.test(remoteProjectName)) {
+        throw new Error((0, devkit_1.stripIndents) `Invalid remote name: ${remoteProjectName}. Remote project names must:
+       - Start with a letter, dollar sign ($) or underscore (_)
+       - Followed by any valid character (letters, digits, underscores, or dollar signs)
+      The regular expression used is ${REMOTE_NAME_REGEX}.`);
+    }
+    const port = options.port ?? (0, lib_1.findNextAvailablePort)(tree);
+    const appInstallTask = await (0, application_1.applicationGenerator)(tree, {
+        ...options,
+        standalone: options.standalone,
+        routing: true,
+        port,
+        skipFormat: true,
+        bundler: 'webpack',
+    });
+    const skipE2E = !options.e2eTestRunner || options.e2eTestRunner === test_runners_1.E2eTestRunner.None;
+    await (0, setup_mf_1.setupMf)(tree, {
+        appName: remoteProjectName,
+        mfType: 'remote',
+        routing: true,
+        host: options.host,
+        port,
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+        skipE2E,
+        e2eProjectName: skipE2E ? undefined : `${remoteProjectName}-e2e`,
+        standalone: options.standalone,
+        prefix: options.prefix,
+        typescriptConfiguration,
+        setParserOptionsProject: options.setParserOptionsProject,
+    });
+    const installTasks = [appInstallTask];
+    if (!options.skipPackageJson) {
+        const installSwcHelpersTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            '@swc/helpers': internal_2.swcHelpersVersion,
+        });
+        installTasks.push(installSwcHelpersTask);
+    }
+    if (options.ssr) {
+        let ssrInstallTask = await (0, lib_1.updateSsrSetup)(tree, {
+            appName: remoteProjectName,
+            port,
+            typescriptConfiguration,
+            standalone: options.standalone,
+            skipPackageJson: options.skipPackageJson,
+            zoneless: options.zoneless,
+        });
+        installTasks.push(ssrInstallTask);
+    }
+    (0, add_mf_env_to_inputs_1.addMfEnvToTargetDefaultInputs)(tree);
+    if (isRspack) {
+        await (0, convert_to_rspack_1.default)(tree, {
+            project: remoteProjectName,
+            skipInstall: options.skipPackageJson,
+            skipFormat: true,
+        });
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, remoteProjectName);
+    project.targets.serve ??= {};
+    project.targets.serve.options ??= {};
+    if (options.host) {
+        project.targets.serve.dependsOn ??= [];
+        project.targets.serve.dependsOn.push(`${options.host}:serve`);
+    }
+    project.targets.serve.options.port = port;
+    (0, devkit_1.updateProjectConfiguration)(tree, remoteProjectName, project);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...installTasks);
+}
+exports.default = remote;

package/dist/src/generators/remote/schema.d.ts

@@ -0,0 +1,30 @@
+import type { Linter, LinterType } from '@nx/eslint';
+import type { E2eTestRunner, UnitTestRunner } from '../../utils/test-runners';
+import type { Styles } from '../utils/types';
+
+export interface Schema {
+  directory: string;
+  name?: string;
+  bundler?: 'webpack' | 'rspack';
+  host?: string;
+  port?: number;
+  setParserOptionsProject?: boolean;
+  skipPackageJson?: boolean;
+  prefix?: string;
+  style?: Styles;
+  skipTests?: boolean;
+  tags?: string;
+  linter?: Linter | LinterType;
+  unitTestRunner?: Exclude<UnitTestRunner, UnitTestRunner.VitestAngular>;
+  e2eTestRunner?: E2eTestRunner;
+  backendProject?: string;
+  strict?: boolean;
+  inlineStyle?: boolean;
+  inlineTemplate?: boolean;
+  viewEncapsulation?: 'Emulated' | 'Native' | 'None';
+  skipFormat?: boolean;
+  standalone?: boolean;
+  ssr?: boolean;
+  zoneless?: boolean;
+  typescriptConfiguration?: boolean;
+}