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

package/dist/cjs/index.js

@@ -35,10 +35,12 @@ __webpack_require__.d(__webpack_exports__, {
     createBuilder: ()=>external_createBuilder_js_namespaceObject.createRspackBuilder,
     isHtmlDisabled: ()=>utils_js_namespaceObject.isHtmlDisabled,
     logger: ()=>core_namespaceObject.logger,
-    parseRspackConfig: ()=>external_createBuilder_js_namespaceObject.parseConfig
+    parseRspackConfig: ()=>external_createBuilder_js_namespaceObject.parseConfig,
+    refreshTsgoCheckerConfig: ()=>tsgo_js_namespaceObject.refreshTsgoCheckerConfig
 });
 const external_createBuilder_js_namespaceObject = require("./createBuilder.js");
 const core_namespaceObject = require("@rsbuild/core");
+const tsgo_js_namespaceObject = require("./shared/tsgo.js");
 const utils_js_namespaceObject = require("./shared/utils.js");
 exports.RUNTIME_CHUNK_NAME = __webpack_exports__.RUNTIME_CHUNK_NAME;
 exports.RUNTIME_CHUNK_REGEX = __webpack_exports__.RUNTIME_CHUNK_REGEX;
@@ -48,6 +50,7 @@ exports.createBuilder = __webpack_exports__.createBuilder;
 exports.isHtmlDisabled = __webpack_exports__.isHtmlDisabled;
 exports.logger = __webpack_exports__.logger;
 exports.parseRspackConfig = __webpack_exports__.parseRspackConfig;
+exports.refreshTsgoCheckerConfig = __webpack_exports__.refreshTsgoCheckerConfig;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "RUNTIME_CHUNK_NAME",
     "RUNTIME_CHUNK_REGEX",
@@ -56,7 +59,8 @@ for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createBuilder",
     "isHtmlDisabled",
     "logger",
-    "parseRspackConfig"
+    "parseRspackConfig",
+    "refreshTsgoCheckerConfig"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/shared/parseCommonConfig.js

@@ -43,6 +43,7 @@ const globalVars_js_namespaceObject = require("../plugins/globalVars.js");
 const htmlMinify_js_namespaceObject = require("../plugins/htmlMinify.js");
 const runtimeChunk_js_namespaceObject = require("../plugins/runtimeChunk.js");
 const external_devServer_js_namespaceObject = require("./devServer.js");
+const external_tsgo_js_namespaceObject = require("./tsgo.js");
 const external_utils_js_namespaceObject = require("./utils.js");
 const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
 const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
@@ -168,7 +169,7 @@ async function parseCommonConfig(builderConfig, options) {
     if (!disableTsChecker) {
         const { pluginTypeCheck } = await import("@rsbuild/plugin-type-check");
         rsbuildPlugins.push(pluginTypeCheck({
-            tsCheckerOptions: tsChecker
+            tsCheckerOptions: (0, external_tsgo_js_namespaceObject.withTsgoDefaults)(tsChecker, options?.cwd ?? process.cwd())
         }));
     }
     if (convertToRem) {

package/dist/cjs/shared/tsgo.js

@@ -0,0 +1,274 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    refreshTsgoCheckerConfig: ()=>refreshTsgoCheckerConfig,
+    withTsgoDefaults: ()=>withTsgoDefaults
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_module_namespaceObject = require("node:module");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const utils_namespaceObject = require("@modern-js/utils");
+const builderRequire = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+const STABLE_TSGO_PACKAGE = "typescript/package.json";
+const NATIVE_PREVIEW_TSGO_PACKAGE = "@typescript/native-preview/package.json";
+const TSGO_CHECKER_DIR = external_node_path_default().join('.modern-js', 'tsgo');
+const tryResolve = (request, rootPath)=>{
+    try {
+        return builderRequire.resolve(request, {
+            paths: [
+                rootPath
+            ]
+        });
+    } catch  {
+        return;
+    }
+};
+const readPackageMajorVersion = (packageJsonPath)=>{
+    try {
+        const packageJson = JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, 'utf8'));
+        const major = Number.parseInt(String(packageJson.version).split('.')[0], 10);
+        return Number.isFinite(major) ? major : void 0;
+    } catch  {
+        return;
+    }
+};
+const resolveTsgoPackagePath = (rootPath)=>{
+    const stableTypeScriptPath = tryResolve(STABLE_TSGO_PACKAGE, rootPath);
+    if (stableTypeScriptPath && (readPackageMajorVersion(stableTypeScriptPath) ?? 0) >= 7) return stableTypeScriptPath;
+    const previewFromProject = tryResolve(NATIVE_PREVIEW_TSGO_PACKAGE, rootPath);
+    if (previewFromProject) return previewFromProject;
+    try {
+        return builderRequire.resolve(NATIVE_PREVIEW_TSGO_PACKAGE);
+    } catch  {
+        return;
+    }
+};
+const toPosixPath = (input)=>input.replaceAll(external_node_path_default().sep, '/');
+const asTsConfigPath = (request)=>{
+    if (external_node_path_default().extname(request)) return [
+        request
+    ];
+    return [
+        request,
+        `${request}.json`
+    ];
+};
+const resolveExtends = (request, configDirectory)=>{
+    const configRequire = (0, external_node_module_namespaceObject.createRequire)(external_node_path_default().join(configDirectory, 'tsconfig.json'));
+    for (const candidate of asTsConfigPath(request)){
+        if (candidate.startsWith('.') || external_node_path_default().isAbsolute(candidate)) {
+            const resolved = external_node_path_default().resolve(configDirectory, candidate);
+            if (external_node_fs_default().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 && !external_node_path_default().isAbsolute(value)) resolved[option] = external_node_path_default().resolve(configDirectory, value);
+    }
+    return resolved;
+};
+const readTsConfig = (configFile, visited = new Set())=>{
+    if (visited.has(configFile) || !external_node_fs_default().existsSync(configFile)) return {};
+    visited.add(configFile);
+    const config = utils_namespaceObject.json5.parse(external_node_fs_default().readFileSync(configFile, 'utf8'));
+    const configDirectory = external_node_path_default().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 (!external_node_fs_default().existsSync(configFile)) return [];
+    const config = utils_namespaceObject.json5.parse(external_node_fs_default().readFileSync(configFile, 'utf8'));
+    if (!Array.isArray(config.references)) return [];
+    const configDirectory = external_node_path_default().dirname(configFile);
+    return config.references.filter((reference)=>'string' == typeof reference?.path).map((reference)=>({
+            ...reference,
+            path: toPosixPath(external_node_path_default().resolve(configDirectory, reference.path))
+        }));
+};
+const toRelativeConfigPath = (fromDirectory, target)=>{
+    const relative = toPosixPath(external_node_path_default().relative(fromDirectory, target));
+    if (relative.startsWith('.')) return relative;
+    return `./${relative}`;
+};
+const writeFileIfChanged = (file, content)=>{
+    if (external_node_fs_default().existsSync(file) && external_node_fs_default().readFileSync(file, 'utf8') === content) return;
+    external_node_fs_default().writeFileSync(file, content);
+};
+const defaultTsgoCheckerConfigFile = (configFile)=>{
+    const hash = (0, external_node_crypto_namespaceObject.createHash)('sha1').update(configFile).digest('hex').slice(0, 10);
+    return external_node_path_default().join(external_node_path_default().dirname(configFile), TSGO_CHECKER_DIR, `tsconfig.${hash}.json`);
+};
+const createTsgoCheckerConfig = (configFile, checkerConfigFile = defaultTsgoCheckerConfigFile(configFile))=>{
+    const configDirectory = external_node_path_default().dirname(configFile);
+    const checkerConfigDirectory = external_node_path_default().dirname(checkerConfigFile);
+    const tsConfig = readTsConfig(configFile);
+    const compilerOptions = {
+        baseUrl: null
+    };
+    const declaredRootDir = tsConfig.compilerOptions?.rootDir;
+    if ('string' == typeof declaredRootDir) compilerOptions.rootDir = toPosixPath(declaredRootDir);
+    else if (tsConfig.compilerOptions?.composite === true) 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
+        } : {}
+    };
+    external_node_fs_default().mkdirSync(checkerConfigDirectory, {
+        recursive: true
+    });
+    writeFileIfChanged(checkerConfigFile, `${JSON.stringify(checkerConfig, null, 2)}\n`);
+    return checkerConfigFile;
+};
+const refreshTsgoCheckerConfig = (checkerConfigFile)=>{
+    const checkerConfigDirectory = external_node_path_default().dirname(checkerConfigFile);
+    if ('tsgo' !== external_node_path_default().basename(checkerConfigDirectory) || '.modern-js' !== external_node_path_default().basename(external_node_path_default().dirname(checkerConfigDirectory)) || !external_node_fs_default().existsSync(checkerConfigFile)) return;
+    let checkerConfig;
+    try {
+        checkerConfig = utils_namespaceObject.json5.parse(external_node_fs_default().readFileSync(checkerConfigFile, 'utf8'));
+    } catch  {
+        return;
+    }
+    if ('string' != typeof checkerConfig.extends) return;
+    const projectConfigFile = external_node_path_default().resolve(checkerConfigDirectory, checkerConfig.extends);
+    if (external_node_fs_default().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(external_node_path_default().resolve(rootPath, typescript.configFile));
+    return config;
+};
+const withTsgoDefaults = (userOptions, rootPath)=>{
+    const tsgoPath = resolveTsgoPackagePath(rootPath);
+    const userChain = userOptions ? Array.isArray(userOptions) ? userOptions : [
+        userOptions
+    ] : [];
+    return [
+        {
+            typescript: tsgoPath ? {
+                tsgo: true,
+                typescriptPath: tsgoPath
+            } : {
+                tsgo: true
+            }
+        },
+        ...userChain,
+        (config)=>{
+            const { typescript } = config;
+            if (typescript?.tsgo === false && typescript.typescriptPath === tsgoPath) typescript.typescriptPath = tryResolve("typescript", rootPath);
+            return normalizeTsgoConfig(config, rootPath);
+        }
+    ];
+};
+exports.refreshTsgoCheckerConfig = __webpack_exports__.refreshTsgoCheckerConfig;
+exports.withTsgoDefaults = __webpack_exports__.withTsgoDefaults;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "refreshTsgoCheckerConfig",
+    "withTsgoDefaults"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -1,3 +1,4 @@
 export { createRspackBuilder as createBuilder, parseConfig as parseRspackConfig } from "./createBuilder.mjs";
 export { logger } from "@rsbuild/core";
+export { refreshTsgoCheckerConfig } from "./shared/tsgo.mjs";
 export { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, isHtmlDisabled } from "./shared/utils.mjs";

package/dist/esm/shared/parseCommonConfig.mjs

@@ -10,6 +10,7 @@ import { pluginGlobalVars } from "../plugins/globalVars.mjs";
 import { pluginHtmlMinifierTerser } from "../plugins/htmlMinify.mjs";
 import { pluginRuntimeChunk } from "../plugins/runtimeChunk.mjs";
 import { transformToRsbuildServerOptions } from "./devServer.mjs";
+import { withTsgoDefaults } from "./tsgo.mjs";
 import { NODE_MODULES_REGEX } from "./utils.mjs";
 const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
 const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
@@ -135,7 +136,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) {

package/dist/esm/shared/tsgo.mjs

@@ -0,0 +1,219 @@
+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 NATIVE_PREVIEW_TSGO_PACKAGE = "@typescript/native-preview/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 readPackageMajorVersion = (packageJsonPath)=>{
+    try {
+        const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf8'));
+        const major = Number.parseInt(String(packageJson.version).split('.')[0], 10);
+        return Number.isFinite(major) ? major : void 0;
+    } catch  {
+        return;
+    }
+};
+const resolveTsgoPackagePath = (rootPath)=>{
+    const stableTypeScriptPath = tryResolve(STABLE_TSGO_PACKAGE, rootPath);
+    if (stableTypeScriptPath && (readPackageMajorVersion(stableTypeScriptPath) ?? 0) >= 7) return stableTypeScriptPath;
+    const previewFromProject = tryResolve(NATIVE_PREVIEW_TSGO_PACKAGE, rootPath);
+    if (previewFromProject) return previewFromProject;
+    try {
+        return builderRequire.resolve(NATIVE_PREVIEW_TSGO_PACKAGE);
+    } catch  {
+        return;
+    }
+};
+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 if (tsConfig.compilerOptions?.composite === true) 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: tsgoPath ? {
+                tsgo: true,
+                typescriptPath: tsgoPath
+            } : {
+                tsgo: true
+            }
+        },
+        ...userChain,
+        (config)=>{
+            const { typescript } = config;
+            if (typescript?.tsgo === false && typescript.typescriptPath === tsgoPath) typescript.typescriptPath = tryResolve("typescript", rootPath);
+            return normalizeTsgoConfig(config, rootPath);
+        }
+    ];
+};
+export { refreshTsgoCheckerConfig, withTsgoDefaults };

package/dist/esm-node/index.mjs

@@ -1,4 +1,5 @@
 import "node:module";
 export { createRspackBuilder as createBuilder, parseConfig as parseRspackConfig } from "./createBuilder.mjs";
 export { logger } from "@rsbuild/core";
+export { refreshTsgoCheckerConfig } from "./shared/tsgo.mjs";
 export { RUNTIME_CHUNK_NAME, RUNTIME_CHUNK_REGEX, SERVICE_WORKER_ENVIRONMENT_NAME, castArray, isHtmlDisabled } from "./shared/utils.mjs";

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

@@ -11,6 +11,7 @@ import { pluginGlobalVars } from "../plugins/globalVars.mjs";
 import { pluginHtmlMinifierTerser } from "../plugins/htmlMinify.mjs";
 import { pluginRuntimeChunk } from "../plugins/runtimeChunk.mjs";
 import { transformToRsbuildServerOptions } from "./devServer.mjs";
+import { withTsgoDefaults } from "./tsgo.mjs";
 import { NODE_MODULES_REGEX } from "./utils.mjs";
 const CSS_MODULES_REGEX = /\.modules?\.\w+$/i;
 const GLOBAL_CSS_REGEX = /\.global\.\w+$/;
@@ -136,7 +137,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) {

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

@@ -0,0 +1,220 @@
+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 NATIVE_PREVIEW_TSGO_PACKAGE = "@typescript/native-preview/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 readPackageMajorVersion = (packageJsonPath)=>{
+    try {
+        const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf8'));
+        const major = Number.parseInt(String(packageJson.version).split('.')[0], 10);
+        return Number.isFinite(major) ? major : void 0;
+    } catch  {
+        return;
+    }
+};
+const resolveTsgoPackagePath = (rootPath)=>{
+    const stableTypeScriptPath = tryResolve(STABLE_TSGO_PACKAGE, rootPath);
+    if (stableTypeScriptPath && (readPackageMajorVersion(stableTypeScriptPath) ?? 0) >= 7) return stableTypeScriptPath;
+    const previewFromProject = tryResolve(NATIVE_PREVIEW_TSGO_PACKAGE, rootPath);
+    if (previewFromProject) return previewFromProject;
+    try {
+        return builderRequire.resolve(NATIVE_PREVIEW_TSGO_PACKAGE);
+    } catch  {
+        return;
+    }
+};
+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 if (tsConfig.compilerOptions?.composite === true) 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: tsgoPath ? {
+                tsgo: true,
+                typescriptPath: tsgoPath
+            } : {
+                tsgo: true
+            }
+        },
+        ...userChain,
+        (config)=>{
+            const { typescript } = config;
+            if (typescript?.tsgo === false && typescript.typescriptPath === tsgoPath) typescript.typescriptPath = tryResolve("typescript", rootPath);
+            return normalizeTsgoConfig(config, rootPath);
+        }
+    ];
+};
+export { refreshTsgoCheckerConfig, withTsgoDefaults };

package/dist/types/index.d.ts

@@ -2,6 +2,7 @@ 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 { BuilderInstance, CreateBuilderOptions };

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

@@ -0,0 +1,27 @@
+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 runs on TypeScript Go (`tsgo`) by default. The checker
+ * prefers the project's stable TypeScript 7 package, then falls back to
+ * `@typescript/native-preview` for projects still on the preview lane.
+ * Set `tools.tsChecker.typescript.tsgo: false` to use the classic checker.
+ */
+export declare const withTsgoDefaults: (userOptions: TsCheckerChain | undefined, rootPath: string) => TsCheckerChain;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bleedingdev/modern-js-builder",
-  "version": "3.9.0-ultramodern.8",
+  "version": "3.9.0-ultramodern.9",
   "description": "A builder for Modern.js",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
   ],
   "dependencies": {
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.8",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.9.0-ultramodern.9",
     "@rsbuild/core": "2.2.3",
     "@rsbuild/plugin-assets-retry": "2.0.2",
     "@rsbuild/plugin-check-syntax": "2.0.1",
@@ -61,7 +61,7 @@
     "ts-deepmerge": "8.0.0"
   },
   "devDependencies": {
-    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.8",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.9.0-ultramodern.9",
     "@rsdoctor/rspack-plugin": "^1.6.3",
     "@rslib/core": "1.0.0",
     "@scripts/rstest-config": "2.66.0",