@nx/rspack 0.0.0-pr-28218-5048fd1

package/src/executors/ssr-dev-server/schema.json

@@ -0,0 +1,36 @@
+{
+  "outputCapture": "direct-nodejs",
+  "title": "Rspack SSR Dev Server",
+  "description": "Serve a SSR application using rspack.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "browserTarget": {
+      "type": "string",
+      "description": "Target which builds the browser application.",
+      "x-priority": "important"
+    },
+    "serverTarget": {
+      "type": "string",
+      "description": "Target which builds the server application.",
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port to be set on `process.env.PORT` for use in the server.",
+      "default": 4200,
+      "x-priority": "important"
+    },
+    "browserTargetOptions": {
+      "type": "object",
+      "description": "Additional options to pass into the browser build target.",
+      "default": {}
+    },
+    "serverTargetOptions": {
+      "type": "object",
+      "description": "Additional options to pass into the server build target.",
+      "default": {}
+    }
+  },
+  "required": ["browserTarget", "serverTarget"]
+}

package/src/executors/ssr-dev-server/ssr-dev-server.impl.d.ts

@@ -0,0 +1,8 @@
+import { ExecutorContext } from '@nx/devkit';
+import { RspackSsrDevServerOptions, TargetOptions } from './schema';
+export declare function ssrDevServerExecutor(options: RspackSsrDevServerOptions, context: ExecutorContext): AsyncGenerator<{
+    baseUrl: string;
+    success: boolean;
+    options: TargetOptions;
+}, void, unknown>;
+export default ssrDevServerExecutor;

package/src/executors/ssr-dev-server/ssr-dev-server.impl.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ssrDevServerExecutor = ssrDevServerExecutor;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const async_iterable_1 = require("@nx/devkit/src/utils/async-iterable");
+const chalk = tslib_1.__importStar(require("chalk"));
+const wait_until_server_is_listening_1 = require("./lib/wait-until-server-is-listening");
+async function* ssrDevServerExecutor(options, context) {
+    const browserTarget = (0, devkit_1.parseTargetString)(options.browserTarget, context.projectGraph);
+    const serverTarget = (0, devkit_1.parseTargetString)(options.serverTarget, context);
+    const browserOptions = (0, devkit_1.readTargetOptions)(browserTarget, context);
+    const serverOptions = (0, devkit_1.readTargetOptions)(serverTarget, context);
+    const runBrowser = await (0, devkit_1.runExecutor)(browserTarget, { ...browserOptions, ...options.browserTargetOptions }, context);
+    const runServer = await (0, devkit_1.runExecutor)(serverTarget, { ...serverOptions, ...options.serverTargetOptions }, context);
+    let browserBuilt = false;
+    let nodeStarted = false;
+    const combined = (0, async_iterable_1.combineAsyncIterables)(runBrowser, runServer);
+    for await (const output of combined) {
+        if (!output.success)
+            throw new Error('Could not build application');
+        if (output.options?.target === 'node') {
+            nodeStarted = true;
+        }
+        else if (output.options?.target === 'web') {
+            browserBuilt = true;
+        }
+        if (nodeStarted && browserBuilt) {
+            await (0, wait_until_server_is_listening_1.waitUntilServerIsListening)(options.port);
+            console.log(`[ ${chalk.green('ready')} ] on http://localhost:${options.port}`);
+            yield {
+                ...output,
+                baseUrl: `http://localhost:${options.port}`,
+            };
+        }
+    }
+}
+exports.default = ssrDevServerExecutor;

package/src/generators/application/application.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { ApplicationGeneratorSchema } from './schema';
+export default function (tree: Tree, _options: ApplicationGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/application/application.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const package_json_1 = require("nx/package.json");
+const configuration_1 = tslib_1.__importDefault(require("../configuration/configuration"));
+const init_1 = tslib_1.__importDefault(require("../init/init"));
+const normalize_options_1 = require("./lib/normalize-options");
+async function default_1(tree, _options) {
+    const tasks = [];
+    const initTask = await (0, init_1.default)(tree, {
+        ..._options,
+        // TODO: Crystalize the default rspack.config.js file.
+        // The default setup isn't crystalized so don't add plugin.
+        addPlugin: false,
+    });
+    tasks.push(initTask);
+    const options = (0, normalize_options_1.normalizeOptions)(tree, _options);
+    options.style ??= 'css';
+    if (options.framework === 'nest') {
+        const { applicationGenerator: nestAppGenerator } = (0, devkit_1.ensurePackage)('@nx/nest', package_json_1.version);
+        const createAppTask = await nestAppGenerator(tree, {
+            ...options,
+            skipFormat: true,
+            tags: options.tags ?? '',
+            addPlugin: false,
+        });
+        const convertAppTask = await (0, configuration_1.default)(tree, {
+            project: options.name,
+            target: 'node',
+            newProject: false,
+            buildTarget: 'build',
+            framework: 'nest',
+        });
+        tasks.push(createAppTask, convertAppTask);
+    }
+    else if (options.framework === 'web') {
+        const { applicationGenerator: webAppGenerator } = (0, devkit_1.ensurePackage)('@nx/web', package_json_1.version);
+        const createAppTask = await webAppGenerator(tree, {
+            bundler: 'webpack',
+            name: options.name,
+            style: options.style,
+            directory: options.directory,
+            tags: options.tags ?? '',
+            unitTestRunner: options.unitTestRunner,
+            e2eTestRunner: options.e2eTestRunner,
+            rootProject: options.rootProject,
+            skipFormat: true,
+            addPlugin: false,
+        });
+        const convertAppTask = await (0, configuration_1.default)(tree, {
+            project: options.name,
+            target: 'web',
+            newProject: false,
+            buildTarget: 'build',
+            serveTarget: 'serve',
+            framework: 'web',
+            addPlugin: false,
+        });
+        tasks.push(createAppTask, convertAppTask);
+    }
+    else {
+        // default to react
+        const { applicationGenerator: reactAppGenerator } = (0, devkit_1.ensurePackage)('@nx/react', package_json_1.version);
+        const createAppTask = await reactAppGenerator(tree, {
+            bundler: 'webpack',
+            name: options.name,
+            style: options.style,
+            directory: options.directory,
+            tags: options.tags ?? '',
+            unitTestRunner: options.unitTestRunner,
+            e2eTestRunner: options.e2eTestRunner,
+            rootProject: options.rootProject,
+            skipFormat: true,
+            addPlugin: false,
+        });
+        const convertAppTask = await (0, configuration_1.default)(tree, {
+            project: options.name,
+            target: 'web',
+            newProject: false,
+            buildTarget: 'build',
+            serveTarget: 'serve',
+            framework: 'react',
+        });
+        tasks.push(createAppTask, convertAppTask);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}

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

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { Framework } from '../../init/schema';
+export declare function editTsConfig(tree: Tree, projectRoot: string, framework: Framework, relativePathToRootTsConfig: string): void;

package/src/generators/application/lib/create-ts-config.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editTsConfig = editTsConfig;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+function editTsConfig(tree, projectRoot, framework, relativePathToRootTsConfig) {
+    // Nx 15.8 moved util to @nx/js, but it is in @nx/workspace in 15.7
+    let shared;
+    try {
+        shared = require('@nx/js/src/utils/typescript/create-ts-config');
+    }
+    catch {
+        shared = require('@nx/workspace/src/utils/create-ts-config');
+    }
+    if (framework === 'react') {
+        const json = {
+            compilerOptions: {
+                jsx: 'react-jsx',
+                allowJs: false,
+                esModuleInterop: false,
+                allowSyntheticDefaultImports: true,
+                strict: true,
+            },
+            files: [],
+            include: [],
+            references: [
+                {
+                    path: './tsconfig.app.json',
+                },
+            ],
+        };
+        // inline tsconfig.base.json into the project
+        if (projectIsRootProjectInStandaloneWorkspace(projectRoot)) {
+            json.compileOnSave = false;
+            json.compilerOptions = {
+                ...shared.tsConfigBaseOptions,
+                ...json.compilerOptions,
+            };
+            json.exclude = ['node_modules', 'tmp'];
+        }
+        else {
+            json.extends = relativePathToRootTsConfig;
+        }
+        (0, devkit_1.writeJson)(tree, `${projectRoot}/tsconfig.json`, json);
+    }
+}
+function projectIsRootProjectInStandaloneWorkspace(projectRoot) {
+    return (0, path_1.relative)(devkit_1.workspaceRoot, projectRoot).length === 0;
+}

package/src/generators/application/lib/normalize-options.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import { ApplicationGeneratorSchema, NormalizedSchema } from '../schema';
+export declare function normalizeDirectory(options: ApplicationGeneratorSchema): string;
+export declare function normalizeProjectName(options: ApplicationGeneratorSchema): string;
+export declare function normalizeOptions(host: Tree, options: ApplicationGeneratorSchema): NormalizedSchema;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDirectory = normalizeDirectory;
+exports.normalizeProjectName = normalizeProjectName;
+exports.normalizeOptions = normalizeOptions;
+const devkit_1 = require("@nx/devkit");
+function normalizeDirectory(options) {
+    const { projectDirectory } = (0, devkit_1.extractLayoutDirectory)(options.directory);
+    return projectDirectory
+        ? `${(0, devkit_1.names)(projectDirectory).fileName}/${(0, devkit_1.names)(options.name).fileName}`
+        : (0, devkit_1.names)(options.name).fileName;
+}
+function normalizeProjectName(options) {
+    return normalizeDirectory(options).replace(new RegExp('/', 'g'), '-');
+}
+function normalizeOptions(host, options) {
+    // --monorepo takes precedence over --rootProject
+    // This won't be needed once we add --bundler=rspack to the @nx/react:app preset
+    const rootProject = !options.monorepo && options.rootProject;
+    const appDirectory = normalizeDirectory(options);
+    const appProjectName = normalizeProjectName(options);
+    const e2eProjectName = options.rootProject
+        ? 'e2e'
+        : `${(0, devkit_1.names)(options.name).fileName}-e2e`;
+    const { layoutDirectory } = (0, devkit_1.extractLayoutDirectory)(options.directory);
+    const appsDir = layoutDirectory ?? (0, devkit_1.getWorkspaceLayout)(host).appsDir;
+    const appProjectRoot = rootProject
+        ? '.'
+        : (0, devkit_1.normalizePath)(`${appsDir}/${appDirectory}`);
+    const normalized = {
+        ...options,
+        rootProject,
+        name: (0, devkit_1.names)(options.name).fileName,
+        projectName: appProjectName,
+        appProjectRoot,
+        e2eProjectName,
+        fileName: 'app',
+    };
+    normalized.unitTestRunner ??= 'jest';
+    normalized.e2eTestRunner ??= 'cypress';
+    return normalized;
+}

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

@@ -0,0 +1,16 @@
+export interface ApplicationGeneratorSchema {
+  name: string;
+  framework?: Framework;
+  style: 'css' | 'scss' | 'less' | 'styl';
+  unitTestRunner?: 'none' | 'jest';
+  e2eTestRunner?: 'none' | 'cypress';
+  directory?: string;
+  tags?: string;
+  rootProject?: boolean;
+  monorepo?: boolean;
+}
+
+export interface NormalizedSchema extends ApplicationGeneratorSchema {
+  appProjectRoot: string;
+  e2eProjectName: string;
+}

package/src/generators/application/schema.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "Application",
+  "title": "Application generator for React + rspack",
+  "type": "object",
+  "description": "React + Rspack application generator.",
+  "examples": [
+    {
+      "command": "nx g app myapp --directory=myorg",
+      "description": "Generate `apps/myorg/myapp` and `apps/myorg/myapp-e2e`"
+    }
+  ],
+  "properties": {
+    "name": {
+      "description": "The name of the application.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the application?",
+      "pattern": "^[a-zA-Z].*$",
+      "x-priority": "important"
+    },
+    "framework": {
+      "type": "string",
+      "description": "The framework to use for the application.",
+      "x-prompt": "What framework do you want to use when generating this application?",
+      "enum": ["none", "react", "web", "nest"],
+      "alias": ["uiFramework"],
+      "x-priority": "important",
+      "default": "react"
+    },
+    "style": {
+      "description": "The file extension to be used for style files.",
+      "type": "string",
+      "default": "css",
+      "alias": "s",
+      "x-prompt": {
+        "message": "Which stylesheet format would you like to use?",
+        "type": "list",
+        "items": [
+          {
+            "value": "css",
+            "label": "CSS"
+          },
+          {
+            "value": "scss",
+            "label": "SASS(.scss)       [ http://sass-lang.com                     ]"
+          },
+          {
+            "value": "styl",
+            "label": "Stylus(.styl)     [ http://stylus-lang.com                   ]"
+          },
+          {
+            "value": "less",
+            "label": "LESS              [ http://lesscss.org                       ]"
+          },
+          {
+            "value": "none",
+            "label": "None"
+          }
+        ]
+      }
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "description": "The unit test runner to use.",
+      "enum": ["none", "jest"],
+      "default": "jest"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "description": "The e2e test runner to use.",
+      "enum": ["none", "cypress"],
+      "default": "cypress"
+    },
+    "directory": {
+      "type": "string",
+      "description": "The directory to nest the app under."
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the application (used for linting).",
+      "alias": "t"
+    },
+    "monorepo": {
+      "type": "boolean",
+      "description": "Creates an integrated monorepo.",
+      "aliases": ["integrated"]
+    },
+    "rootProject": {
+      "type": "boolean",
+      "x-priority": "internal"
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/configuration/configuration.d.ts

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

package/src/generators/configuration/configuration.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationGenerator = configurationGenerator;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const generator_utils_1 = require("../../utils/generator-utils");
+const create_ts_config_1 = require("../application/lib/create-ts-config");
+const init_1 = tslib_1.__importDefault(require("../init/init"));
+async function configurationGenerator(tree, options) {
+    const task = await (0, init_1.default)(tree, {
+        ...options,
+        // TODO: Crystalize the default rspack.config.js file.
+        // The default setup isn't crystalized so don't add plugin.
+        addPlugin: false,
+    });
+    const { targets, root, projectType } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const { target, framework } = (0, generator_utils_1.determineFrameworkAndTarget)(tree, options, root, targets);
+    options.framework = framework;
+    options.target = target;
+    let foundStylePreprocessorOptions;
+    let buildTargetName = 'build';
+    let serveTargetName = 'serve';
+    /**
+     * This is for when we are converting an existing project
+     * to use the vite executors.
+     */
+    let projectAlreadyHasRspackTargets = {};
+    if (!options.newProject) {
+        const userProvidedTargetName = {
+            build: options.buildTarget,
+            serve: options.serveTarget,
+        };
+        const { validFoundTargetName, projectContainsUnsupportedExecutor, userProvidedTargetIsUnsupported, alreadyHasNxRspackTargets, } = (0, generator_utils_1.findExistingTargetsInProject)(targets, userProvidedTargetName);
+        projectAlreadyHasRspackTargets = alreadyHasNxRspackTargets;
+        if (alreadyHasNxRspackTargets.build &&
+            (alreadyHasNxRspackTargets.serve ||
+                projectType === 'library' ||
+                options.framework === 'nest')) {
+            throw new Error(`The project ${options.project} is already configured to use the @nx/rspack executors.
+        Please try a different project, or remove the existing targets
+        and re-run this generator to reset the existing Rspack Configuration.
+        `);
+        }
+        if (!validFoundTargetName.build && projectContainsUnsupportedExecutor) {
+            throw new Error(`The project ${options.project} cannot be converted to use the @nx/rspack executors.`);
+        }
+        if (!projectContainsUnsupportedExecutor &&
+            !validFoundTargetName.build &&
+            !validFoundTargetName.serve) {
+            await (0, generator_utils_1.handleUnknownExecutors)(options.project);
+        }
+        await (0, generator_utils_1.handleUnsupportedUserProvidedTargets)(userProvidedTargetIsUnsupported, userProvidedTargetName, validFoundTargetName, options.framework);
+        /**
+         * Once the user is at this stage, then they can go ahead and convert.
+         */
+        buildTargetName = validFoundTargetName.build ?? buildTargetName;
+        serveTargetName = validFoundTargetName.serve ?? serveTargetName;
+        // Not needed atm
+        // if (projectType === 'application' && options.target !== 'node') {
+        //   moveAndEditIndexHtml(tree, options, buildTargetName);
+        // }
+        foundStylePreprocessorOptions =
+            targets?.[buildTargetName]?.options?.stylePreprocessorOptions;
+        (0, generator_utils_1.deleteWebpackConfig)(tree, root, targets?.[buildTargetName]?.options?.webpackConfig);
+        (0, create_ts_config_1.editTsConfig)(tree, root, options.framework, (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(root), 'tsconfig.base.json'));
+    }
+    if (!projectAlreadyHasRspackTargets.build) {
+        (0, generator_utils_1.addOrChangeBuildTarget)(tree, options, buildTargetName);
+    }
+    if ((options.framework !== 'none' || options.devServer) &&
+        options.framework !== 'nest' &&
+        !projectAlreadyHasRspackTargets.serve) {
+        (0, generator_utils_1.addOrChangeServeTarget)(tree, options, serveTargetName);
+    }
+    (0, generator_utils_1.writeRspackConfigFile)(tree, options, foundStylePreprocessorOptions);
+    await (0, devkit_1.formatFiles)(tree);
+    return task;
+}
+exports.default = configurationGenerator;

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

@@ -0,0 +1,12 @@
+import { InitGeneratorSchema } from '../init/schema';
+
+export interface ConfigurationSchema extends InitGeneratorSchema {
+  project: string;
+  main?: string;
+  tsConfig?: string;
+  target?: 'node' | 'web';
+  skipValidation?: boolean;
+  newProject?: boolean;
+  buildTarget?: string;
+  serveTarget?: string;
+}

package/src/generators/configuration/schema.json

@@ -0,0 +1,73 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "Rspack",
+  "title": "Nx Rspack Configuration Generator",
+  "description": "Rspack configuration generator.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-dropdown": "project",
+      "x-prompt": "What is the name of the project to set up a rspack for?",
+      "x-priority": "important"
+    },
+    "framework": {
+      "type": "string",
+      "description": "The framework used by the project.",
+      "x-prompt": "What framework is the project you want to convert using?",
+      "enum": ["none", "react", "web", "nest"],
+      "alias": ["uiFramework"],
+      "x-priority": "important"
+    },
+    "main": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the main entry file. Defaults to '<projectRoot>/src/main.ts'.",
+      "x-priority": "important"
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "Path relative to the workspace root for the tsconfig file to build with. Defaults to '<projectRoot>/tsconfig.app.json'.",
+      "x-priority": "important"
+    },
+    "target": {
+      "type": "string",
+      "description": "Target platform for the build, same as the rspack config option.",
+      "enum": ["node", "web"],
+      "default": "web"
+    },
+    "devServer": {
+      "type": "boolean",
+      "description": "Add a serve target to run a local rspack dev-server",
+      "default": false
+    },
+    "style": {
+      "type": "string",
+      "description": "The style solution to use.",
+      "enum": ["none", "css", "scss", "less"]
+    },
+    "newProject": {
+      "type": "boolean",
+      "description": "Is this a new project?",
+      "default": false,
+      "hidden": true
+    },
+    "buildTarget": {
+      "type": "string",
+      "description": "The build target of the project to be transformed to use the @nx/vite:build executor."
+    },
+    "serveTarget": {
+      "type": "string",
+      "description": "The serve target of the project to be transformed to use the @nx/vite:dev-server and @nx/vite:preview-server executors."
+    },
+    "rootProject": {
+      "type": "boolean",
+      "x-priority": "internal"
+    }
+  },
+  "required": ["project"]
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { InitGeneratorSchema } from './schema';
+export declare function rspackInitGenerator(tree: Tree, schema: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default rspackInitGenerator;
+export declare const rspackInitSchematic: (generatorOptions: InitGeneratorSchema) => (tree: any, context: any) => Promise<any>;

package/src/generators/init/init.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rspackInitSchematic = void 0;
+exports.rspackInitGenerator = rspackInitGenerator;
+const devkit_1 = require("@nx/devkit");
+const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
+const js_1 = require("@nx/js");
+const plugin_1 = require("../../../plugin");
+const versions_1 = require("../../utils/versions");
+async function rspackInitGenerator(tree, schema) {
+    const tasks = [];
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    if (schema.addPlugin) {
+        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/rspack/plugin', plugin_1.createNodesV2, {
+            buildTargetName: [
+                'build',
+                'rspack:build',
+                'build:rspack',
+                'rspack-build',
+                'build-rspack',
+            ],
+            serveTargetName: [
+                'serve',
+                'rspack:serve',
+                'serve:rspack',
+                'rspack-serve',
+                'serve-rspack',
+            ],
+            previewTargetName: [
+                'preview',
+                'rspack:preview',
+                'preview:rspack',
+                'rspack-preview',
+                'preview-rspack',
+            ],
+        }, schema.updatePackageScripts);
+    }
+    const jsInitTask = await (0, js_1.initGenerator)(tree, {
+        ...schema,
+        tsConfigName: schema.rootProject ? 'tsconfig.json' : 'tsconfig.base.json',
+        skipFormat: true,
+    });
+    tasks.push(jsInitTask);
+    const devDependencies = {
+        '@rspack/core': versions_1.rspackCoreVersion,
+        '@rspack/cli': versions_1.rspackCoreVersion,
+        '@rspack/plugin-minify': versions_1.rspackPluginMinifyVersion,
+        '@rspack/plugin-react-refresh': versions_1.rspackPluginReactRefreshVersion,
+        'react-refresh': versions_1.reactRefreshVersion,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const version = require('../../../package.json').version;
+    if (version !== '0.0.1') {
+        // Ignored for local dev / e2e tests.
+        devDependencies['@nx/rspack'] = version;
+    }
+    if (schema.style === 'less') {
+        devDependencies['less-loader'] = versions_1.lessLoaderVersion;
+    }
+    if (schema.framework !== 'none' || schema.devServer) {
+        devDependencies['@rspack/dev-server'] = versions_1.rspackDevServerVersion;
+    }
+    const installTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, schema.keepExistingVersions);
+    tasks.push(installTask);
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = rspackInitGenerator;
+exports.rspackInitSchematic = (0, devkit_1.convertNxGenerator)(rspackInitGenerator);

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

@@ -0,0 +1,11 @@
+export type Framework = 'none' | 'react' | 'web' | 'nest';
+
+export interface InitGeneratorSchema {
+  addPlugin?: boolean;
+  devServer?: boolean;
+  framework?: Framework;
+  keepExistingVersions?: boolean;
+  rootProject?: boolean;
+  style?: 'none' | 'css' | 'scss' | 'less' | 'styl';
+  updatePackageScripts?: boolean;
+}