@nx/rspack/src/generators/configuration/configuration.js

The Nx Plugin for Rspack contains executors and generators that support building applications using Rspack.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.configurationGenerator = configurationGenerator;
const tslib_1 = require("tslib");
const devkit_1 = require("@nx/devkit");
const path_1 = require("path");
const generator_utils_1 = require("../../utils/generator-utils");
const init_1 = tslib_1.__importDefault(require("../init/init"));
const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
function projectIsRootProjectInStandaloneWorkspace(projectRoot) {
    return (0, path_1.relative)(devkit_1.workspaceRoot, projectRoot).length === 0;
}
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);
    }
}
async function configurationGenerator(tree, options) {
    const task = await (0, init_1.default)(tree, {
        ...options,
    });
    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 ||
                (0, ts_solution_setup_1.getProjectType)(tree, options.project, 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);
        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;