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

package/src/generators/init/schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "Init",
+  "title": "Nx Rspack Init Generator",
+  "type": "object",
+  "description": "Rspack init generator.",
+  "properties": {
+    "framework": {
+      "type": "string",
+      "description": "The UI framework used by the project.",
+      "enum": ["none", "react", "web", "nest"],
+      "alias": ["uiFramework"]
+    },
+    "style": {
+      "type": "string",
+      "description": "The style solution to use.",
+      "enum": ["none", "css", "scss", "less", "styl"]
+    },
+    "rootProject": {
+      "type": "boolean",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/generators/preset/preset.d.ts

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

package/src/generators/preset/preset.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const devkit_1 = require("@nx/devkit");
+const application_1 = tslib_1.__importDefault(require("../application/application"));
+async function default_1(tree, options) {
+    const appTask = (0, application_1.default)(tree, {
+        ...options,
+        // Since `--style` is not passed down to custom preset, we're using individual flags for now.
+        style: options.sass
+            ? 'scss'
+            : options.less
+                ? 'less'
+                : options.stylus
+                    ? 'styl'
+                    : 'css',
+    });
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        json.scripts ??= {};
+        json.scripts.build ??= 'npx nx build';
+        json.scripts.start ??= 'npx nx serve';
+        json.scripts.lint ??= 'npx nx lint';
+        json.scripts.test ??= 'npx nx test';
+        json.scripts.e2e ??= 'npx nx e2e e2e';
+        return json;
+    });
+    if (options.rootProject) {
+        // Remove these folders so projects will be generated at the root.
+        tree.delete('apps');
+        tree.delete('libs');
+    }
+    return appTask;
+}

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

@@ -0,0 +1,18 @@
+export interface PresetGeneratorSchema {
+  name: string;
+  framework?: Framework;
+  less?: boolean;
+  sass?: boolean;
+  stylus?: boolean;
+  unitTestRunner?: 'none' | 'jest';
+  e2eTestRunner?: 'none' | 'cypress';
+  directory?: string;
+  tags?: string;
+  rootProject?: boolean;
+  monorepo?: boolean;
+}
+
+export interface NormalizedSchema extends PresetGeneratorSchema {
+  appProjectRoot: string;
+  e2eProjectName: string;
+}

package/src/generators/preset/schema.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "Preset",
+  "title": "Standalone React and rspack preset",
+  "description": "React + Rspack preset generator.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-priority": "important"
+    },
+    "framework": {
+      "type": "string",
+      "description": "The framework to use for the application.",
+      "enum": ["none", "react", "web", "nest"],
+      "alias": ["uiFramework"],
+      "x-priority": "important",
+      "default": "react"
+    },
+    "less": {
+      "type": "boolean",
+      "description": "Use less for styling."
+    },
+    "sass": {
+      "type": "boolean",
+      "description": "Use sass for styling."
+    },
+    "stylus": {
+      "type": "boolean",
+      "description": "Use stylus for styling."
+    },
+    "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 project (used for linting).",
+      "alias": "t"
+    },
+    "monorepo": {
+      "type": "boolean",
+      "description": "Creates an integrated monorepo.",
+      "default": false,
+      "aliases": ["integrated"]
+    },
+    "rootProject": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "default": true
+    }
+  },
+  "required": ["name"]
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './generators/configuration/configuration';
+export * from './generators/init/init';
+export * from './utils/config';
+export * from './utils/with-nx';
+export * from './utils/with-react';
+export * from './utils/with-web';

package/src/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./generators/configuration/configuration"), exports);
+tslib_1.__exportStar(require("./generators/init/init"), exports);
+tslib_1.__exportStar(require("./utils/config"), exports);
+tslib_1.__exportStar(require("./utils/with-nx"), exports);
+tslib_1.__exportStar(require("./utils/with-react"), exports);
+tslib_1.__exportStar(require("./utils/with-web"), exports);

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

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

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replacePackage;
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/rspack', '@nx/rspack');
+    await (0, devkit_1.formatFiles)(tree);
+}

package/src/plugins/generate-package-json-plugin.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorContext } from '@nx/devkit';
+import { type Compiler, type RspackPluginInstance } from '@rspack/core';
+export declare class GeneratePackageJsonPlugin implements RspackPluginInstance {
+    private readonly options;
+    private readonly context;
+    private readonly projectGraph;
+    constructor(options: {
+        tsConfig: string;
+        outputFileName: string;
+    }, context: ExecutorContext);
+    apply(compiler: Compiler): void;
+}

package/src/plugins/generate-package-json-plugin.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratePackageJsonPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const webpack_sources_1 = require("webpack-sources");
+const pluginName = 'GeneratePackageJsonPlugin';
+class GeneratePackageJsonPlugin {
+    constructor(options, context) {
+        this.options = options;
+        this.context = context;
+        this.projectGraph = context.projectGraph;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+            compilation.hooks.processAssets.tap({
+                name: pluginName,
+                stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+            }, () => {
+                const helperDependencies = (0, js_1.getHelperDependenciesFromProjectGraph)(this.context.root, this.context.projectName, this.projectGraph);
+                const importHelpers = !!(0, js_1.readTsConfig)(this.options.tsConfig).options
+                    .importHelpers;
+                const shouldAddHelperDependency = importHelpers &&
+                    helperDependencies.every((dep) => dep.target !== js_1.HelperDependency.tsc);
+                if (shouldAddHelperDependency) {
+                    helperDependencies.push({
+                        type: 'static',
+                        source: this.context.projectName,
+                        target: js_1.HelperDependency.tsc,
+                    });
+                }
+                const packageJson = (0, js_1.createPackageJson)(this.context.projectName, this.projectGraph, {
+                    target: this.context.targetName,
+                    root: this.context.root,
+                    isProduction: true,
+                    helperDependencies: helperDependencies.map((dep) => dep.target),
+                });
+                packageJson.main = packageJson.main ?? this.options.outputFileName;
+                compilation.emitAsset('package.json', new webpack_sources_1.RawSource((0, devkit_1.serializeJson)(packageJson)));
+                const packageManager = (0, devkit_1.detectPackageManager)(this.context.root);
+                compilation.emitAsset((0, js_1.getLockFileName)(packageManager), new webpack_sources_1.RawSource((0, js_1.createLockFile)(packageJson, this.projectGraph, packageManager)));
+            });
+        });
+    }
+}
+exports.GeneratePackageJsonPlugin = GeneratePackageJsonPlugin;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,9 @@
+import { CreateDependencies, CreateNodesV2 } from '@nx/devkit';
+export interface RspackPluginOptions {
+    buildTargetName?: string;
+    serveTargetName?: string;
+    serveStaticTargetName?: string;
+    previewTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodesV2: CreateNodesV2<RspackPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const js_1 = require("@nx/js");
+const fs_1 = require("fs");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const path_1 = require("path");
+const read_rspack_options_1 = require("../utils/read-rspack-options");
+const resolve_user_defined_rspack_config_1 = require("../utils/resolve-user-defined-rspack-config");
+function readTargetsCache(cachePath) {
+    return (0, fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+const createDependencies = () => {
+    return [];
+};
+exports.createDependencies = createDependencies;
+const rspackConfigGlob = '**/rspack.config.{js,ts,mjs,mts,cjs,cts}';
+exports.createNodesV2 = [
+    rspackConfigGlob,
+    async (configFilePaths, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `rspack-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        try {
+            return await (0, devkit_1.createNodesFromFiles)((configFile, options, context) => createNodesInternal(configFile, options, context, targetsCache), configFilePaths, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
+async function createNodesInternal(configFilePath, options, context, targetsCache) {
+    const projectRoot = (0, path_1.dirname)(configFilePath);
+    // 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));
+    if (!siblingFiles.includes('package.json') &&
+        !siblingFiles.includes('project.json')) {
+        return {};
+    }
+    const normalizedOptions = normalizeOptions(options);
+    // We do not want to alter how the hash is calculated, so appending the config file path to the hash
+    // to prevent vite/vitest files overwriting the target cache created by the other
+    const hash = (await (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, normalizedOptions, context, [(0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))])) + configFilePath;
+    targetsCache[hash] ??= await createRspackTargets(configFilePath, projectRoot, normalizedOptions, context);
+    const { targets, metadata } = targetsCache[hash];
+    return {
+        projects: {
+            [projectRoot]: {
+                root: projectRoot,
+                targets,
+                metadata,
+            },
+        },
+    };
+}
+async function createRspackTargets(configFilePath, projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const rspackConfig = (0, resolve_user_defined_rspack_config_1.resolveUserDefinedRspackConfig)((0, path_1.join)(context.workspaceRoot, configFilePath), (0, js_1.getRootTsConfigPath)(), true);
+    const rspackOptions = await (0, read_rspack_options_1.readRspackOptions)(rspackConfig);
+    const outputPath = normalizeOutputPath(rspackOptions.output?.path, projectRoot);
+    const targets = {};
+    targets[options.buildTargetName] = {
+        command: `rspack build`,
+        options: { cwd: projectRoot, args: ['--node-env=production'] },
+        cache: true,
+        dependsOn: [`^${options.buildTargetName}`],
+        inputs: 'production' in namedInputs
+            ? [
+                'production',
+                '^production',
+                {
+                    externalDependencies: ['@rspack/cli'],
+                },
+            ]
+            : [
+                'default',
+                '^default',
+                {
+                    externalDependencies: ['@rspack/cli'],
+                },
+            ],
+        outputs: [outputPath],
+    };
+    targets[options.serveTargetName] = {
+        command: `rspack serve`,
+        options: {
+            cwd: projectRoot,
+            args: ['--node-env=development'],
+        },
+    };
+    targets[options.previewTargetName] = {
+        command: `rspack serve`,
+        options: {
+            cwd: projectRoot,
+            args: ['--node-env=production'],
+        },
+    };
+    targets[options.serveStaticTargetName] = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: options.buildTargetName,
+            spa: true,
+        },
+    };
+    return { targets, metadata: {} };
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.serveTargetName ??= 'serve';
+    options.previewTargetName ??= 'preview';
+    options.serveStaticTargetName ??= 'serve-static';
+    return options;
+}
+function normalizeOutputPath(outputPath, projectRoot) {
+    if (!outputPath) {
+        // If outputPath is undefined, use rspack's default `dist` directory.
+        if (projectRoot === '.') {
+            return `{projectRoot}/dist`;
+        }
+        else {
+            return `{workspaceRoot}/dist/{projectRoot}`;
+        }
+    }
+    else {
+        if ((0, path_1.isAbsolute)(outputPath)) {
+            /**
+             * If outputPath is absolute, we need to resolve it relative to the workspaceRoot first.
+             * After that, we can use the relative path to the workspaceRoot token {workspaceRoot} to generate the output path.
+             */
+            return `{workspaceRoot}/${(0, path_1.relative)(devkit_1.workspaceRoot, (0, path_1.resolve)(devkit_1.workspaceRoot, outputPath))}`;
+        }
+        else {
+            if (outputPath.startsWith('..')) {
+                return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, outputPath));
+            }
+            else {
+                return (0, path_1.join)('{projectRoot}', outputPath);
+            }
+        }
+    }
+}

package/src/utils/config.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { Configuration } from '@rspack/core';
+import { SharedConfigContext } from './model';
+export declare const nxRspackComposablePlugin = "nxRspackComposablePlugin";
+export declare function isNxRspackComposablePlugin(a: unknown): a is AsyncNxComposableRspackPlugin;
+export interface NxRspackExecutionContext {
+    options: unknown;
+    context: ExecutorContext;
+    configuration?: string;
+}
+export interface NxComposableRspackPlugin {
+    (config: Configuration, ctx: NxRspackExecutionContext): Configuration;
+}
+export interface AsyncNxComposableRspackPlugin {
+    (config: Configuration, ctx: NxRspackExecutionContext): Configuration | Promise<Configuration>;
+}
+export declare function composePlugins(...plugins: any[]): (config: Configuration, ctx: SharedConfigContext) => Promise<Configuration>;

package/src/utils/config.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxRspackComposablePlugin = void 0;
+exports.isNxRspackComposablePlugin = isNxRspackComposablePlugin;
+exports.composePlugins = composePlugins;
+exports.nxRspackComposablePlugin = 'nxRspackComposablePlugin';
+function isNxRspackComposablePlugin(a) {
+    return a?.[exports.nxRspackComposablePlugin] === true;
+}
+function composePlugins(...plugins) {
+    return Object.defineProperty(async function combined(config, ctx) {
+        for (const plugin of plugins) {
+            const fn = await plugin;
+            config = await fn(config, ctx);
+        }
+        return config;
+    }, exports.nxRspackComposablePlugin, {
+        value: true,
+        enumerable: false,
+        writable: false,
+    });
+}

package/src/utils/create-compiler.d.ts

@@ -0,0 +1,7 @@
+import { ExecutorContext } from '@nx/devkit';
+import { Compiler, MultiCompiler } from '@rspack/core';
+import { RspackExecutorSchema } from '../executors/rspack/schema';
+export declare function createCompiler(options: RspackExecutorSchema & {
+    devServer?: any;
+}, context: ExecutorContext): Promise<Compiler | MultiCompiler>;
+export declare function isMultiCompiler(compiler: Compiler | MultiCompiler): compiler is MultiCompiler;

package/src/utils/create-compiler.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompiler = createCompiler;
+exports.isMultiCompiler = isMultiCompiler;
+const tslib_1 = require("tslib");
+const core_1 = require("@rspack/core");
+const path = tslib_1.__importStar(require("path"));
+const resolve_user_defined_rspack_config_1 = require("./resolve-user-defined-rspack-config");
+async function createCompiler(options, context) {
+    const pathToConfig = path.join(context.root, options.rspackConfig);
+    let userDefinedConfig = {};
+    if (options.tsConfig) {
+        userDefinedConfig = (0, resolve_user_defined_rspack_config_1.resolveUserDefinedRspackConfig)(pathToConfig, options.tsConfig);
+    }
+    else {
+        userDefinedConfig = await Promise.resolve(`${pathToConfig}`).then(s => tslib_1.__importStar(require(s))).then((x) => x.default || x);
+    }
+    if (typeof userDefinedConfig.then === 'function') {
+        userDefinedConfig = await userDefinedConfig;
+    }
+    let config = {};
+    if (typeof userDefinedConfig === 'function') {
+        config = await userDefinedConfig({ devServer: options.devServer }, { options, context });
+    }
+    else {
+        config = userDefinedConfig;
+        config.devServer ??= options.devServer;
+    }
+    return (0, core_1.rspack)(config);
+}
+function isMultiCompiler(compiler) {
+    return 'compilers' in compiler;
+}

package/src/utils/generator-utils.d.ts

@@ -0,0 +1,34 @@
+import { TargetConfiguration, Tree } from '@nx/devkit';
+import { ConfigurationSchema } from '../generators/configuration/schema';
+import { Framework } from '../generators/init/schema';
+export type Target = 'build' | 'serve';
+export type TargetFlags = Partial<Record<Target, boolean>>;
+export type UserProvidedTargetName = Partial<Record<Target, string>>;
+export type ValidFoundTargetName = Partial<Record<Target, string>>;
+export declare function findExistingTargetsInProject(targets: {
+    [targetName: string]: TargetConfiguration;
+}, userProvidedTargets?: UserProvidedTargetName): {
+    validFoundTargetName: ValidFoundTargetName;
+    projectContainsUnsupportedExecutor: boolean;
+    userProvidedTargetIsUnsupported: TargetFlags;
+    alreadyHasNxRspackTargets: TargetFlags;
+};
+export declare function addOrChangeBuildTarget(tree: Tree, options: ConfigurationSchema, target: string): void;
+export declare function addOrChangeServeTarget(tree: Tree, options: ConfigurationSchema, target: string): void;
+export declare function writeRspackConfigFile(tree: Tree, options: ConfigurationSchema, stylePreprocessorOptions?: {
+    includePaths?: string[];
+}): void;
+export declare function deleteWebpackConfig(tree: Tree, projectRoot: string, webpackConfigFilePath?: string): void;
+export declare function moveAndEditIndexHtml(tree: Tree, options: ConfigurationSchema, buildTarget: string): void;
+export declare function normalizeViteConfigFilePathWithTree(tree: Tree, projectRoot: string, configFile?: string): string;
+export declare function getViteConfigPathForProject(tree: Tree, projectName: string, target?: string): string;
+export declare function handleUnsupportedUserProvidedTargets(userProvidedTargetIsUnsupported: TargetFlags, userProvidedTargetName: UserProvidedTargetName, validFoundTargetName: ValidFoundTargetName, framework: Framework): Promise<void>;
+export declare function handleUnknownExecutors(projectName: string): Promise<void>;
+export declare function determineFrameworkAndTarget(tree: Tree, options: ConfigurationSchema, projectRoot: string, targets: {
+    [targetName: string]: TargetConfiguration<any>;
+}): {
+    target: 'node' | 'web';
+    framework?: Framework;
+};
+export declare function determineMain(tree: Tree, options: ConfigurationSchema): string;
+export declare function determineTsConfig(tree: Tree, options: ConfigurationSchema): string;