@bleedingdev/modern-js-builder 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/dist/esm-node/plugins/rscConfig.mjs

@@ -7,19 +7,26 @@ var __rspack_import_meta_dirname__ = __rspack_dirname(__rspack_fileURLToPath(imp
 const ASYNC_STORAGE_PATTERN = /universal[/\\]async_storage/;
 const SERVER_LOADER_ENTRY_PATTERN = /[/\\](?:server-loader-combined|route-server-loaders)\.js$/;
 const RENDER_RSC_SOURCE_PATTERN = /render[/\\].*[/\\]server[/\\]rsc/;
-const RENDER_RSC_RSLIB_ENTRY_PATTERN = /render[/\\]dist[/\\]esm[/\\]rsc(?:Worker)?\.mjs$/;
-const RENDER_RSC_RUNTIME = '@modern-js/render/rsc';
-const RENDER_RSC_WORKER_RUNTIME = '@modern-js/render/rsc-worker';
+const RENDER_RSC_RSLIB_ENTRY_PATTERN = /render[/\\]dist[/\\]esm[/\\]rsc(?:\.edge)?\.mjs$/;
 const RSC_COMMON_LAYER = 'rsc-common';
 const ENTRY_NAME_VAR = '__MODERN_JS_ENTRY_NAME';
 const ROUTE_DATA_FILE_PATTERN = /[/\\]routes[/\\](?:.*[/\\])?(?:layout|page|\$)\.(?:loader|data)\.[tj]sx?(?:\?.*)?$/;
 const createVirtualModule = (content)=>`data:text/javascript,${encodeURIComponent(content)}`;
+const resolveRscEnvironments = (environments)=>{
+    const resolved = {
+        server: environments?.server ?? 'server',
+        client: environments?.client ?? 'client'
+    };
+    for (const [role, name] of Object.entries(resolved))if ('string' != typeof name || !name.trim()) throw new TypeError(`RSC ${role} environment must have a nonempty name`);
+    return resolved;
+};
 const isAsyncStorageExclude = (exclude)=>{
     if ('string' == typeof exclude) return ASYNC_STORAGE_PATTERN.test(exclude);
     if (exclude instanceof RegExp) return exclude.test('universal/async_storage') || exclude.test('universal\\async_storage');
     return false;
 };
-function pluginRscConfig() {
+function pluginRscConfig(environments, rscLayerMatchers = []) {
+    const serverEnvironment = resolveRscEnvironments(environments).server;
     return {
         name: 'builder:rsc-config',
         setup (api) {
@@ -32,9 +39,8 @@ function pluginRscConfig() {
                 return layersCache;
             };
             api.modifyBundlerChain({
-                handler: (chain, { isServer })=>{
-                    if (isServer) {
-                        chain.resolve.alias.set(`${RENDER_RSC_RUNTIME}$`, RENDER_RSC_WORKER_RUNTIME);
+                handler: (chain, { isServer, environment })=>{
+                    if (isServer || environment.name === serverEnvironment) {
                         let emptyModulePath;
                         try {
                             emptyModulePath = require.resolve('../shared/rsc/rscEmptyModule');
@@ -57,9 +63,25 @@ function pluginRscConfig() {
                 order: 'pre'
             });
             api.modifyRspackConfig(async (config, utils)=>{
-                const isServer = 'node' === config.target || 'node' === utils.target || utils.environment?.name === 'server';
+                const isServer = 'node' === config.target || 'node' === utils.target || utils.environment?.name === serverEnvironment;
                 if (!isServer) return;
                 const Layers = await getLayers();
+                if (utils.environment?.name !== serverEnvironment && rscLayerMatchers.length > 0) {
+                    config.module ??= {};
+                    config.module.rules ??= [];
+                    config.module.rules.push({
+                        test: rscLayerMatchers,
+                        layer: Layers.rsc
+                    }, {
+                        issuerLayer: Layers.rsc,
+                        resolve: {
+                            conditionNames: [
+                                'react-server',
+                                '...'
+                            ]
+                        }
+                    });
+                }
                 if (config.entry) {
                     const entries = config.entry;
                     const newEntries = {};
@@ -96,8 +118,8 @@ function pluginRscConfig() {
                     });
                 }
             });
-            api.modifyBundlerChain((chain, { isServer, isWebWorker })=>{
-                if (!isServer && !isWebWorker) {
+            api.modifyBundlerChain((chain, { isServer, isWebWorker, environment })=>{
+                if (!isServer && !isWebWorker && environment.name !== serverEnvironment) {
                     const entries = chain.entryPoints.entries();
                     if (entries && 'object' == typeof entries) for (const entryName of Object.keys(entries)){
                         const entryPoint = chain.entry(entryName);
@@ -111,13 +133,12 @@ function pluginRscConfig() {
 }
 async function getRscPlugins(enableRsc, internalDirectory, environments) {
     if (enableRsc) {
+        const rscEnvironments = resolveRscEnvironments(environments);
         const rscLayerMatchers = createRscLayerMatchers(internalDirectory);
         const { pluginRSC } = await import("rsbuild-plugin-rsc");
         return [
             pluginRSC({
-                ...environments ? {
-                    environments
-                } : {},
+                environments: rscEnvironments,
                 layers: {
                     ssr: SERVER_LOADER_ENTRY_PATTERN,
                     rsc: [
@@ -128,7 +149,7 @@ async function getRscPlugins(enableRsc, internalDirectory, environments) {
                     ]
                 }
             }),
-            pluginRscConfig()
+            pluginRscConfig(rscEnvironments, rscLayerMatchers)
         ];
     }
     return [];

package/dist/esm-node/shared/parseCommonConfig.mjs

@@ -2,7 +2,6 @@ import "node:module";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { pluginCssMinimizer } from "@rsbuild/plugin-css-minimizer";
 import { pluginLess } from "@rsbuild/plugin-less";
-import { pluginReact } from "@rsbuild/plugin-react";
 import { pluginSass } from "@rsbuild/plugin-sass";
 import { pluginDevtool } from "../plugins/devtools.mjs";
 import { pluginEmitRouteFile } from "../plugins/emitRouteFile.mjs";
@@ -11,7 +10,9 @@ import { pluginGlobalVars } from "../plugins/globalVars.mjs";
 import { pluginHtmlMinifierTerser } from "../plugins/htmlMinify.mjs";
 import { pluginRuntimeChunk } from "../plugins/runtimeChunk.mjs";
 import { transformToRsbuildServerOptions } from "./devServer.mjs";
-import { NODE_MODULES_REGEX } from "./utils.mjs";
+import { normalizeLessOptions, normalizeSassOptions, resolveSvgrOptions } from "./pluginOptions.mjs";
+import { withTsgoDefaults } from "./tsgo.mjs";
+import { NODE_MODULES_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME } from "./utils.mjs";
 const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
 const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
 const DEFAULT_CSS_MINIFIER_OPTIONS = {
@@ -37,7 +38,7 @@ function removeUndefinedKey(obj) {
 }
 async function parseCommonConfig(builderConfig, options) {
     const frameworkConfigPath = options?.frameworkConfigPath;
-    const { plugins: [...plugins] = [], splitChunks, performance: { ...performanceConfig } = {}, output: { module = false, enableCssModuleTSDeclaration, disableCssModuleExtension, disableTsChecker, disableSvgr, svgDefaultExport, assetsRetry, enableAssetManifest, sourceMap, convertToRem, polyfill, dataUriLimit = 10000, distPath = {}, ...outputConfig } = {}, html: { outputStructure, appIcon, ...htmlConfig } = {}, source: { alias, globalVars, transformImport, reactCompiler, ...sourceConfig } = {}, dev = {}, server = {}, security: { checkSyntax, sri, ...securityConfig } = {}, tools: { devServer, tsChecker, minifyCss, less, sass, htmlPlugin, autoprefixer, ...toolsConfig } = {}, environments = {}, resolve = {} } = builderConfig;
+    const { plugins: [...plugins] = [], splitChunks, performance: { ...performanceConfig } = {}, output: { module = false, enableCssModuleTSDeclaration, disableCssModuleExtension, disableTsChecker, disableSvgr, svgDefaultExport, assetsRetry, enableAssetManifest, sourceMap, convertToRem, polyfill, dataUriLimit = 10000, distPath = {}, ...outputConfig } = {}, html: { outputStructure, appIcon, ...htmlConfig } = {}, source: { alias, globalVars, transformImport, reactCompiler, ...sourceConfig } = {}, dev = {}, server = {}, security: { checkSyntax, sri, ...securityConfig } = {}, tools: { devServer, tsChecker, minifyCss, less, sass, svgr, htmlPlugin, autoprefixer, ...toolsConfig } = {}, environments = {}, resolve = {} } = builderConfig;
     let combinedAlias;
     if (alias || resolve.alias) combinedAlias = [].concat(alias ?? []).concat(resolve.alias ?? []);
     const rsbuildConfig = {
@@ -120,12 +121,8 @@ async function parseCommonConfig(builderConfig, options) {
             sourceMap
         }),
         pluginEmitRouteFile(),
-        pluginSass({
-            sassLoaderOptions: sass
-        }),
-        pluginLess({
-            lessLoaderOptions: less
-        }),
+        pluginSass(normalizeSassOptions(sass)),
+        pluginLess(normalizeLessOptions(less)),
         pluginEnvironmentDefaults(distPath),
         pluginHtmlMinifierTerser()
     ];
@@ -136,7 +133,7 @@ async function parseCommonConfig(builderConfig, options) {
     if (!disableTsChecker) {
         const { pluginTypeCheck } = await import("@rsbuild/plugin-type-check");
         rsbuildPlugins.push(pluginTypeCheck({
-            tsCheckerOptions: tsChecker
+            tsCheckerOptions: withTsgoDefaults(tsChecker, options?.cwd ?? process.cwd())
         }));
     }
     if (convertToRem) {
@@ -152,19 +149,44 @@ async function parseCommonConfig(builderConfig, options) {
         const { pluginSourceBuild } = await import("@rsbuild/plugin-source-build");
         rsbuildPlugins.push(pluginSourceBuild(true === sourceBuild ? {} : sourceBuild));
     }
-    rsbuildPlugins.push(pluginReact(options?.disableReactCompiler || void 0 === reactCompiler ? {} : {
-        reactCompiler
-    }));
-    if (!disableSvgr) {
-        const { pluginSvgr } = await import("@rsbuild/plugin-svgr");
-        rsbuildPlugins.push(pluginSvgr({
-            mixedImport: true,
-            parallel: true,
-            svgrOptions: {
-                exportType: 'component' === svgDefaultExport ? 'default' : 'named'
-            }
-        }));
-    }
+    rsbuildPlugins.push({
+        name: 'rsbuild:react',
+        async setup (api) {
+            const { pluginReact } = await import("@rsbuild/plugin-react");
+            return pluginReact().setup(api);
+        }
+    });
+    if (!options?.disableReactCompiler && void 0 !== reactCompiler) rsbuildPlugins.push({
+        name: 'builder:react-compiler',
+        setup (api) {
+            api.modifyEnvironmentConfig((config, { name, mergeEnvironmentConfig })=>'web' === config.output.target && name !== SERVICE_WORKER_ENVIRONMENT_NAME ? mergeEnvironmentConfig({
+                    tools: {
+                        swc: {
+                            jsc: {
+                                transform: {
+                                    reactCompiler
+                                }
+                            }
+                        }
+                    }
+                }, config) : config);
+        }
+    });
+    const svgrOptions = resolveSvgrOptions({
+        svgr,
+        disableSvgr,
+        svgDefaultExport
+    });
+    if (false !== svgrOptions) rsbuildPlugins.push({
+        name: 'rsbuild:svgr',
+        pre: [
+            'rsbuild:react'
+        ],
+        async setup (api) {
+            const { pluginSvgr } = await import("@rsbuild/plugin-svgr");
+            await pluginSvgr(svgrOptions).setup(api);
+        }
+    });
     if (assetsRetry) {
         const { pluginAssetsRetry } = await import("@rsbuild/plugin-assets-retry");
         rsbuildPlugins.push(pluginAssetsRetry(assetsRetry));

package/dist/esm-node/shared/pluginOptions.mjs

@@ -0,0 +1,76 @@
+import "node:module";
+import { applyOptionsChain, isDevCommand, logger } from "@modern-js/utils";
+const LESS_PLUGIN_KEYS = [
+    'lessLoaderOptions',
+    'include',
+    'exclude',
+    'parallel'
+];
+const SASS_PLUGIN_KEYS = [
+    'sassLoaderOptions',
+    'include',
+    'exclude',
+    'rewriteUrls'
+];
+const warned = new Set();
+const resetPluginOptionsWarnings = ()=>{
+    warned.clear();
+};
+const warnOnceInDev = (key, message)=>{
+    if (!isDevCommand() || warned.has(key)) return;
+    warned.add(key);
+    logger.warn(message);
+};
+const isPlainObject = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isPluginLevelOptions = (value, pluginKeys)=>isPlainObject(value) && pluginKeys.some((key)=>key in value);
+const isEmptyObject = (value)=>isPlainObject(value) && 0 === Object.keys(value).length;
+const warnIgnoredKeys = (name, value, pluginKeys, loaderOptionsKey)=>{
+    const pluginLevel = Object.keys(value).filter((key)=>pluginKeys.includes(key));
+    const ignored = Object.keys(value).filter((key)=>!pluginKeys.includes(key));
+    if (0 === ignored.length) return;
+    warnOnceInDev(`${name}:mixed`, `\`${name}\` contains plugin-level options (${pluginLevel.join(', ')}) together with other keys (${ignored.join(', ')}). The whole object is passed to the plugin, so the other keys are ignored. Move loader options under \`${loaderOptionsKey}\`.`);
+};
+const normalizeLessOptions = (less)=>{
+    if (isPluginLevelOptions(less, LESS_PLUGIN_KEYS)) {
+        warnIgnoredKeys('tools.less', less, LESS_PLUGIN_KEYS, 'lessLoaderOptions');
+        return less;
+    }
+    if (void 0 !== less && !isEmptyObject(less)) warnOnceInDev('tools.less', "`tools.less` now accepts the full options of @rsbuild/plugin-less. Passing less-loader options directly is deprecated and will stop working in the next major version. Move them under `lessLoaderOptions`:\n  before: tools: { less: { lessOptions: { javascriptEnabled: true } } }\n  after:  tools: { less: { lessLoaderOptions: { lessOptions: { javascriptEnabled: true } } } }");
+    return {
+        lessLoaderOptions: less
+    };
+};
+const normalizeSassOptions = (sass)=>{
+    if (isPluginLevelOptions(sass, SASS_PLUGIN_KEYS)) {
+        warnIgnoredKeys('tools.sass', sass, SASS_PLUGIN_KEYS, 'sassLoaderOptions');
+        return sass;
+    }
+    if (void 0 !== sass && !isEmptyObject(sass)) warnOnceInDev('tools.sass', "`tools.sass` now accepts the full options of @rsbuild/plugin-sass. Passing sass-loader options directly is deprecated and will stop working in the next major version. Move them under `sassLoaderOptions`:\n  before: tools: { sass: { sassOptions: { quietDeps: true } } }\n  after:  tools: { sass: { sassLoaderOptions: { sassOptions: { quietDeps: true } } } }");
+    return {
+        sassLoaderOptions: sass
+    };
+};
+const mergeSvgrOptions = (target, source)=>{
+    const svgrOptions = source.svgrOptions ? {
+        ...target.svgrOptions,
+        ...source.svgrOptions
+    } : target.svgrOptions;
+    return Object.assign(target, source, {
+        svgrOptions
+    });
+};
+const resolveSvgrOptions = ({ svgr, disableSvgr, svgDefaultExport })=>{
+    if (void 0 !== disableSvgr) warnOnceInDev('output.disableSvgr', disableSvgr ? '`output.disableSvgr` is deprecated and will be removed in the next major version. Use `tools: { svgr: false }` instead.' : '`output.disableSvgr` is deprecated and will be removed in the next major version. SVGR is enabled by default, so `output.disableSvgr: false` can be removed (or use `tools: { svgr: {} }` to keep it explicit).');
+    if (void 0 !== svgDefaultExport) warnOnceInDev('output.svgDefaultExport', "`output.svgDefaultExport` is deprecated and will be removed in the next major version. Use `tools.svgr.svgrOptions.exportType` instead:\n  before: output: { svgDefaultExport: 'component' }\n  after:  tools: { svgr: { svgrOptions: { exportType: 'default' } } }\n  ('url' maps to exportType: 'named')");
+    if (false === svgr) return false;
+    if (void 0 === svgr && disableSvgr) return false;
+    const defaults = {
+        mixedImport: true,
+        parallel: true,
+        svgrOptions: {
+            exportType: 'component' === svgDefaultExport ? 'default' : 'named'
+        }
+    };
+    return applyOptionsChain(defaults, svgr, void 0, mergeSvgrOptions);
+};
+export { normalizeLessOptions, normalizeSassOptions, resetPluginOptionsWarnings, resolveSvgrOptions };

package/dist/esm-node/shared/tsgo.mjs

@@ -0,0 +1,199 @@
+import "node:module";
+import { createHash } from "node:crypto";
+import node_fs from "node:fs";
+import { createRequire } from "node:module";
+import node_path from "node:path";
+import { json5 } from "@modern-js/utils";
+const builderRequire = createRequire(import.meta.url);
+const STABLE_TSGO_PACKAGE = "typescript/package.json";
+const TSGO_CHECKER_DIR = node_path.join('.modern-js', 'tsgo');
+const tryResolve = (request, rootPath)=>{
+    try {
+        return builderRequire.resolve(request, {
+            paths: [
+                rootPath
+            ]
+        });
+    } catch  {
+        return;
+    }
+};
+const resolveTsgoPackagePath = (rootPath)=>{
+    const packageJsonPath = tryResolve(STABLE_TSGO_PACKAGE, rootPath) ?? builderRequire.resolve(STABLE_TSGO_PACKAGE);
+    const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf8'));
+    if ("typescript" !== packageJson.name || '7.0.2' !== packageJson.version) throw new Error(`The native type checker requires typescript@7.0.2; found ${String(packageJson.name)}@${String(packageJson.version)} at ${packageJsonPath}.`);
+    return packageJsonPath;
+};
+const toPosixPath = (input)=>input.replaceAll(node_path.sep, '/');
+const asTsConfigPath = (request)=>{
+    if (node_path.extname(request)) return [
+        request
+    ];
+    return [
+        request,
+        `${request}.json`
+    ];
+};
+const resolveExtends = (request, configDirectory)=>{
+    const configRequire = createRequire(node_path.join(configDirectory, 'tsconfig.json'));
+    for (const candidate of asTsConfigPath(request)){
+        if (candidate.startsWith('.') || node_path.isAbsolute(candidate)) {
+            const resolved = node_path.resolve(configDirectory, candidate);
+            if (node_fs.existsSync(resolved)) return resolved;
+            continue;
+        }
+        try {
+            return configRequire.resolve(candidate);
+        } catch  {}
+    }
+};
+const PATH_COMPILER_OPTIONS = [
+    'rootDir',
+    'outDir',
+    'declarationDir'
+];
+const absolutiseConfigPaths = (compilerOptions, configDirectory)=>{
+    if (!compilerOptions) return {};
+    const resolved = {
+        ...compilerOptions
+    };
+    for (const option of PATH_COMPILER_OPTIONS){
+        const value = resolved[option];
+        if ('string' == typeof value && !node_path.isAbsolute(value)) resolved[option] = node_path.resolve(configDirectory, value);
+    }
+    return resolved;
+};
+const readTsConfig = (configFile, visited = new Set())=>{
+    if (visited.has(configFile) || !node_fs.existsSync(configFile)) return {};
+    visited.add(configFile);
+    const config = json5.parse(node_fs.readFileSync(configFile, 'utf8'));
+    const configDirectory = node_path.dirname(configFile);
+    const extendsList = Array.isArray(config.extends) ? config.extends : config.extends ? [
+        config.extends
+    ] : [];
+    const baseConfig = extendsList.reduce((merged, request)=>{
+        const resolved = resolveExtends(request, configDirectory);
+        if (!resolved) return merged;
+        const parentConfig = readTsConfig(resolved, visited);
+        return {
+            ...merged,
+            compilerOptions: {
+                ...merged.compilerOptions ?? {},
+                ...parentConfig.compilerOptions ?? {}
+            }
+        };
+    }, {});
+    return {
+        ...baseConfig,
+        compilerOptions: {
+            ...baseConfig.compilerOptions ?? {},
+            ...absolutiseConfigPaths(config.compilerOptions, configDirectory)
+        }
+    };
+};
+const readProjectReferences = (configFile)=>{
+    if (!node_fs.existsSync(configFile)) return [];
+    const config = json5.parse(node_fs.readFileSync(configFile, 'utf8'));
+    if (!Array.isArray(config.references)) return [];
+    const configDirectory = node_path.dirname(configFile);
+    return config.references.filter((reference)=>'string' == typeof reference?.path).map((reference)=>({
+            ...reference,
+            path: toPosixPath(node_path.resolve(configDirectory, reference.path))
+        }));
+};
+const toRelativeConfigPath = (fromDirectory, target)=>{
+    const relative = toPosixPath(node_path.relative(fromDirectory, target));
+    if (relative.startsWith('.')) return relative;
+    return `./${relative}`;
+};
+const writeFileIfChanged = (file, content)=>{
+    if (node_fs.existsSync(file) && node_fs.readFileSync(file, 'utf8') === content) return;
+    node_fs.writeFileSync(file, content);
+};
+const defaultTsgoCheckerConfigFile = (configFile)=>{
+    const hash = createHash('sha1').update(configFile).digest('hex').slice(0, 10);
+    return node_path.join(node_path.dirname(configFile), TSGO_CHECKER_DIR, `tsconfig.${hash}.json`);
+};
+const createTsgoCheckerConfig = (configFile, checkerConfigFile = defaultTsgoCheckerConfigFile(configFile))=>{
+    const configDirectory = node_path.dirname(configFile);
+    const checkerConfigDirectory = node_path.dirname(checkerConfigFile);
+    const tsConfig = readTsConfig(configFile);
+    const compilerOptions = {
+        baseUrl: null
+    };
+    const declaredRootDir = tsConfig.compilerOptions?.rootDir;
+    if ('string' == typeof declaredRootDir) compilerOptions.rootDir = toPosixPath(declaredRootDir);
+    else compilerOptions.rootDir = toPosixPath(configDirectory);
+    const moduleResolution = String(tsConfig.compilerOptions?.moduleResolution).toLowerCase();
+    if ([
+        'node',
+        'node10'
+    ].includes(moduleResolution)) compilerOptions.moduleResolution = null;
+    const references = readProjectReferences(configFile);
+    const checkerConfig = {
+        extends: toRelativeConfigPath(checkerConfigDirectory, configFile),
+        compilerOptions,
+        ...references.length > 0 ? {
+            references
+        } : {}
+    };
+    node_fs.mkdirSync(checkerConfigDirectory, {
+        recursive: true
+    });
+    writeFileIfChanged(checkerConfigFile, `${JSON.stringify(checkerConfig, null, 2)}\n`);
+    return checkerConfigFile;
+};
+const refreshTsgoCheckerConfig = (checkerConfigFile)=>{
+    const checkerConfigDirectory = node_path.dirname(checkerConfigFile);
+    if ('tsgo' !== node_path.basename(checkerConfigDirectory) || '.modern-js' !== node_path.basename(node_path.dirname(checkerConfigDirectory)) || !node_fs.existsSync(checkerConfigFile)) return;
+    let checkerConfig;
+    try {
+        checkerConfig = json5.parse(node_fs.readFileSync(checkerConfigFile, 'utf8'));
+    } catch  {
+        return;
+    }
+    if ('string' != typeof checkerConfig.extends) return;
+    const projectConfigFile = node_path.resolve(checkerConfigDirectory, checkerConfig.extends);
+    if (node_fs.existsSync(projectConfigFile)) try {
+        createTsgoCheckerConfig(projectConfigFile, checkerConfigFile);
+    } catch  {}
+    return projectConfigFile;
+};
+const normalizeTsgoConfig = (config, rootPath)=>{
+    const { typescript } = config;
+    if (typescript?.tsgo === false) return config;
+    const compilerOptions = {
+        ...typescript?.configOverwrite?.compilerOptions ?? {},
+        baseUrl: null
+    };
+    if ([
+        'node',
+        'node10'
+    ].includes(String(compilerOptions.moduleResolution).toLowerCase())) compilerOptions.moduleResolution = null;
+    config.typescript = {
+        ...typescript,
+        configOverwrite: {
+            ...typescript?.configOverwrite ?? {},
+            compilerOptions
+        }
+    };
+    if (typescript?.configFile) config.typescript.configFile = createTsgoCheckerConfig(node_path.resolve(rootPath, typescript.configFile));
+    return config;
+};
+const withTsgoDefaults = (userOptions, rootPath)=>{
+    const tsgoPath = resolveTsgoPackagePath(rootPath);
+    const userChain = userOptions ? Array.isArray(userOptions) ? userOptions : [
+        userOptions
+    ] : [];
+    return [
+        {
+            typescript: {
+                tsgo: true,
+                typescriptPath: tsgoPath
+            }
+        },
+        ...userChain,
+        (config)=>normalizeTsgoConfig(config, rootPath)
+    ];
+};
+export { refreshTsgoCheckerConfig, withTsgoDefaults };

package/dist/types/index.d.ts

@@ -2,7 +2,8 @@ import { type BuilderInstance, createRspackBuilder } from './createBuilder.js';
 import type { CreateBuilderOptions } from './types.js';
 export { type ChainIdentifier, type ConfigChain, logger, type NormalizedConfig, type RsbuildConfig, type RsbuildContext, type RsbuildPlugin, type RsbuildPlugins, type RsbuildTarget, type Rspack, type RspackChain, } from '@rsbuild/core';
 export { parseConfig as parseRspackConfig } from './createBuilder.js';
+export { refreshTsgoCheckerConfig } from './shared/tsgo.js';
 export { castArray, isHtmlDisabled, RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, } from './shared/utils.js';
-export type { BuilderConfig, BundlerType, CacheGroup, MetaOptions, MultiStats, RspackConfig, Stats, ToolsDevServerConfig, } from './types.js';
+export type { BuilderConfig, BuilderSvgOptions, BundlerType, CacheGroup, MetaOptions, MultiStats, RspackConfig, Stats, ToolsDevServerConfig, } from './types.js';
 export type { BuilderInstance, CreateBuilderOptions };
 export { createRspackBuilder as createBuilder };

package/dist/types/plugins/rscConfig.d.ts

@@ -8,7 +8,10 @@ import type { RsbuildPlugin } from '@rsbuild/core';
  * 4. Adding entry name virtual module for client-side entries
  * 5. Adding 'use server-entry' directive to route components
  */
-export declare function pluginRscConfig(): RsbuildPlugin;
+export declare function pluginRscConfig(environments?: {
+    server?: string;
+    client?: string;
+}, rscLayerMatchers?: RegExp[]): RsbuildPlugin;
 /**
  * Get RSC plugins based on configuration
  * @param enableRsc - Whether RSC is enabled

package/dist/types/shared/pluginOptions.d.ts

@@ -0,0 +1,32 @@
+import type { PluginLessOptions } from '@rsbuild/plugin-less';
+import type { PluginSassOptions } from '../sass/index.js';
+import type { PluginSvgrOptions, SvgDefaultExport } from '@rsbuild/plugin-svgr';
+import type { BuilderConfig } from '../types.js';
+type BuilderToolsConfig = NonNullable<BuilderConfig['tools']>;
+/** Reset the warn-once state. Only meant for unit tests. */
+export declare const resetPluginOptionsWarnings: () => void;
+/**
+ * `tools.less` accepts either the full options of `@rsbuild/plugin-less`
+ * or, for backward compatibility, the less-loader options directly
+ * (object, function or array form). The legacy form is wrapped into
+ * `lessLoaderOptions` so the generated bundler config stays unchanged.
+ */
+export declare const normalizeLessOptions: (less: BuilderToolsConfig['less']) => PluginLessOptions;
+/**
+ * Same as {@link normalizeLessOptions} for `tools.sass`.
+ */
+export declare const normalizeSassOptions: (sass: BuilderToolsConfig['sass']) => PluginSassOptions;
+/**
+ * Resolve the options passed to `@rsbuild/plugin-svgr`, or `false` when the
+ * plugin should not be registered.
+ *
+ * `tools.svgr` takes precedence over the deprecated `output.disableSvgr` and
+ * `output.svgDefaultExport`; the two legacy options keep working when
+ * `tools.svgr` is not set.
+ */
+export declare const resolveSvgrOptions: ({ svgr, disableSvgr, svgDefaultExport, }: {
+    svgr: BuilderToolsConfig['svgr'];
+    disableSvgr?: boolean;
+    svgDefaultExport?: SvgDefaultExport;
+}) => PluginSvgrOptions | false;
+export {};

package/dist/types/shared/tsgo.d.ts

@@ -0,0 +1,25 @@
+import type { PluginTypeCheckerOptions } from '@rsbuild/plugin-type-check';
+type TsCheckerChain = NonNullable<PluginTypeCheckerOptions['tsCheckerOptions']>;
+type TsCheckerFn = Extract<TsCheckerChain, (config: never) => unknown>;
+export type TsCheckerOptions = Parameters<TsCheckerFn>[0];
+/**
+ * Regenerate a checker config from the project config it `extends`.
+ *
+ * The generated file is written once, at builder configuration; everything it
+ * inherits through `extends` is read fresh by the compiler on every check, but
+ * the values it has to restate (`references`, the pinned `rootDir`, the
+ * `moduleResolution` override) would otherwise stay frozen for the life of a
+ * `modern dev` session. The checker calls this before each run so an edit to
+ * the project's tsconfig - adding, removing or retargeting a project reference -
+ * takes effect on the next compilation instead of the next restart.
+ *
+ * Returns the project config the checker config was derived from, so the caller
+ * can watch it; `undefined` when the file is not a generated checker config.
+ */
+export declare const refreshTsgoCheckerConfig: (checkerConfigFile: string) => string | undefined;
+/**
+ * Type checking uses the canonical stable TypeScript 7.0.2 package by default,
+ * supplied by the project or the builder's declared production dependency.
+ */
+export declare const withTsgoDefaults: (userOptions: TsCheckerChain | undefined, rootPath: string) => TsCheckerChain;
+export {};

package/dist/types/types.d.ts

@@ -1,16 +1,20 @@
-import type { AliasOption } from '@modern-js/utils';
+import type { AliasOption } from '@modern-js/utils/alias';
 import type { ConfigChain, ConfigChainWithContext, DevConfig, DistPathConfig, EnvironmentConfig, HtmlConfig, OutputConfig, Polyfill, RsbuildConfig, RsbuildPluginAPI, RsbuildPlugins, RsbuildTarget, Rspack, SecurityConfig, ServerConfig, SourceConfig, ToolsConfig } from '@rsbuild/core';
 import type { PluginAssetsRetryOptions } from '@rsbuild/plugin-assets-retry';
 import type { PluginCheckSyntaxOptions } from '@rsbuild/plugin-check-syntax';
 import type { PluginCssMinimizerOptions } from './css-minimizer/index.js';
 import type { PluginLessOptions } from '@rsbuild/plugin-less';
-import type { PluginReactOptions } from '@rsbuild/plugin-react';
 import type { PluginRemOptions } from '@rsbuild/plugin-rem';
 import type { PluginSassOptions } from './sass/index.js';
 import type { PluginSourceBuildOptions } from '@rsbuild/plugin-source-build';
-type SvgDefaultExport = 'component' | 'url';
 import type { PluginTypeCheckerOptions } from '@rsbuild/plugin-type-check';
 import type { Options as AutoprefixerOptions } from 'autoprefixer';
+/** Renderer-owned SVG compiler options, registered by the selected React owner. */
+export interface BuilderSvgOptions {
+}
+type RegisteredSvgOptions = BuilderSvgOptions extends {
+    options: infer Options;
+} ? Options : never;
 export type CacheGroup = Rspack.OptimizationSplitChunksCacheGroup;
 export type Stats = Omit<Rspack.Stats, '#private' | 'hash' | 'startTime' | 'endTime'>;
 export type RspackConfig = Rspack.Configuration;
@@ -105,13 +109,29 @@ export type BuilderExtraConfig = {
          */
         minifyCss?: PluginCssMinimizerOptions['pluginOptions'];
         /**
-         * Modify the config of [less-loader](https://github.com/webpack-contrib/less-loader).
+         * Modify the options of [@rsbuild/plugin-less](https://rsbuild.rs/plugins/list/plugin-less),
+         * such as `lessLoaderOptions`, `include`, `exclude` and `parallel`.
+         *
+         * Passing the [less-loader](https://github.com/webpack-contrib/less-loader)
+         * options directly is still supported for backward compatibility, but is
+         * deprecated: move them under `lessLoaderOptions`.
          */
-        less?: PluginLessOptions['lessLoaderOptions'];
+        less?: PluginLessOptions['lessLoaderOptions'] | PluginLessOptions;
         /**
-         * Modify the config of [sass-loader](https://github.com/webpack-contrib/sass-loader).
+         * Modify the options of [@rsbuild/plugin-sass](https://rsbuild.rs/plugins/list/plugin-sass),
+         * such as `sassLoaderOptions`, `include`, `exclude` and `rewriteUrls`.
+         *
+         * Passing the [sass-loader](https://github.com/webpack-contrib/sass-loader)
+         * options directly is still supported for backward compatibility, but is
+         * deprecated: move them under `sassLoaderOptions`.
          */
-        sass?: PluginSassOptions['sassLoaderOptions'];
+        sass?: PluginSassOptions['sassLoaderOptions'] | PluginSassOptions;
+        /**
+         * Modify the options of [@rsbuild/plugin-svgr](https://rsbuild.rs/plugins/list/plugin-svgr),
+         * such as `svgrOptions`, `parallel`, `exclude` and `query`.
+         * Set to `false` to disable SVGR; all `.svg` files are then treated as static assets.
+         */
+        svgr?: [RegisteredSvgOptions] extends [never] ? false : ConfigChain<RegisteredSvgOptions> | false;
     };
     dev?: {
         /** Set the page URL to open when the server starts. */
@@ -150,10 +170,13 @@ export type BuilderExtraConfig = {
          * The transform is enabled by default through Rsbuild's SWC integration.
          * Set this to `false` to disable it.
          *
+         * Only browser environments (`output.target: 'web'`) are compiled;
+         * `node` and `web-worker` (SSR, BFF) environments never are.
+         *
          * For React 17 or 18, install `react-compiler-runtime` and set the
          * matching target version, for example `{ target: '18' }`.
          */
-        reactCompiler?: PluginReactOptions['reactCompiler'];
+        reactCompiler?: Rspack.SwcLoaderTransformConfig['reactCompiler'];
     };
     output?: {
         /**
@@ -186,10 +209,14 @@ export type BuilderExtraConfig = {
         disableTsChecker?: boolean;
         /**
          * Configure the default export type of SVG files.
+         * @deprecated Use `tools.svgr.svgrOptions.exportType` instead:
+         * `'component'` maps to `exportType: 'default'`, `'url'` maps to `exportType: 'named'`.
          */
-        svgDefaultExport?: SvgDefaultExport;
+        svgDefaultExport?: 'component' | 'url';
         /**
          * Whether to transform SVGs into React components. If true, will treat all .svg files as assets.
+         * @deprecated Use `tools.svgr` instead: `output.disableSvgr: true` maps to `tools.svgr: false`;
+         * `false` is the default behavior and can simply be removed.
          */
         disableSvgr?: boolean;
     };