rsbuild-plugin-dts 0.21.5 → 0.22.0

package/README.md

@@ -326,6 +326,55 @@ pluginDts({
 }
 ```
 
+### isolated
+
+- **Type:** `boolean`
+- **Default:** `false`
+
+Whether to generate declaration files with [isolatedDeclarations](https://www.typescriptlang.org/tsconfig/#isolatedDeclarations).
+
+> This option was added in Rslib v0.22.0 and is currently still experimental.
+
+When enabled, `rsbuild-plugin-dts` uses Rspack's built-in SWC fast_dts capability to generate declaration files directly during the build.
+
+```js
+pluginDts({
+  isolated: true,
+});
+```
+
+When enabling this option, we recommend also enabling `isolatedDeclarations` in `tsconfig.json` so TypeScript can surface code that does not satisfy the `isolatedDeclarations` constraints earlier.
+
+```json
+{
+  "compilerOptions": {
+    "isolatedDeclarations": true
+  }
+}
+```
+
+#### Use cases
+
+By default, `rsbuild-plugin-dts` generates declaration files through the TypeScript Compiler API, and it can also generate declaration files by enabling [tsgo](#tsgo). Unlike these two approaches, `isolated` does not perform full type checking during declaration file generation, so it is more suitable for use with another independent, high-performance type checking workflow.
+
+For example, in a monorepo project, you can use this option together with [`rslint --type-check`](https://rslint.rs/guide/type-checking):
+
+- Use `rslint --type-check` as the unified type checking step.
+- Use `isolated` to quickly output declaration files when building each package.
+
+This preserves full type checking while reducing the cost of repeatedly running TypeScript type analysis, loading TypeScript or `tsgo` related packages, and loading native bindings during each package build, making the overall build pipeline lighter.
+
+#### Output scope
+
+`isolated` generates declaration files based on the module dependency graph during the Rspack build. Only entry modules and modules referenced by entry modules will generate corresponding declaration files. If a file is not included in the build dependency graph, it will not automatically generate declaration files like TypeScript does. If you want declaration files to be generated for these files as well, add them to [source.entry](https://rslib.rs/config/rsbuild/source#sourceentry), or make sure they are referenced by an existing entry.
+
+#### Usage constraints
+
+- `isolated` is currently only available when `pluginDts` is used through Rslib, because it requires Rslib's built-in RslibPlugin.
+- `isolated` cannot be enabled together with [tsgo](#tsgo).
+- `isolated` cannot be enabled together with [build](#build).
+- When `isolated` is enabled, [abortOnError](#abortonerror) cannot be set to `false`.
+
 ## Contributing
 
 Please read the [Contributing Guide](https://github.com/web-infra-dev/rslib/blob/main/CONTRIBUTING.md).

package/dist/{350.js → 981.js}

@@ -1,10 +1,10 @@
 import node_fs from "node:fs";
+import node_path, { basename, dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve } from "node:path";
+import { logger } from "@rsbuild/core";
 import promises from "node:fs/promises";
 import { createRequire } from "node:module";
 import { platform } from "node:os";
-import node_path, { basename, dirname, extname, isAbsolute, join, normalize, relative as external_node_path_relative, resolve } from "node:path";
 import { styleText } from "node:util";
-import { logger } from "@rsbuild/core";
 import * as __rspack_external_fs from "fs";
 import { readdir, readdirSync, realpath, realpathSync, stat as external_fs_stat, statSync } from "fs";
 import { basename as external_path_basename, dirname as external_path_dirname, isAbsolute as external_path_isAbsolute, normalize as external_path_normalize, posix, relative as external_path_relative, resolve as external_path_resolve, sep as external_path_sep } from "path";
@@ -1842,7 +1842,7 @@ const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1)=>{
     }
     callback$1(entries, directoryPath, currentDepth);
 };
-function build(isSynchronous) {
+function dist_build(isSynchronous) {
     return isSynchronous ? walkSync : walkAsync;
 }
 var Queue = class {
@@ -1927,7 +1927,7 @@ var Walker = class {
         this.getArray = build$4(options);
         this.groupFiles = build$3(options);
         this.resolveSymlink = build$2(options, this.isSynchronous);
-        this.walkDirectory = build(this.isSynchronous);
+        this.walkDirectory = dist_build(this.isSynchronous);
     }
     start() {
         this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
@@ -3666,7 +3666,25 @@ async function redirectDtsImports(dtsFile, dtsExtension, redirect, matchPath, ou
             const ext = extname(redirectImportPath);
             const shouldAddExtension = redirectImportPath !== importPath || importPath.startsWith('.') || isAbsolute(importPath);
             if (ext) if (JS_EXTENSIONS_PATTERN.test(redirectImportPath)) {
-                if (redirect.extension) redirectImportPath = redirectImportPath.replace(/\.[^.]+$/, jsExtension);
+                if (redirect.extension) {
+                    let redirectJsExtension = jsExtension;
+                    const pathWithoutExtension = redirectImportPath.replace(/\.[^.]+$/, '');
+                    let importDtsExtension;
+                    if ([
+                        '.mjs',
+                        '.mjsx',
+                        '.mts',
+                        '.mtsx'
+                    ].includes(ext)) importDtsExtension = '.d.mts';
+                    else if ([
+                        '.cjs',
+                        '.cjsx',
+                        '.cts',
+                        '.ctsx'
+                    ].includes(ext)) importDtsExtension = '.d.cts';
+                    if (importDtsExtension && await pathExists(join(dirname(dtsFile), `${pathWithoutExtension}${importDtsExtension}`))) redirectJsExtension = '.d.mts' === importDtsExtension ? '.mjs' : '.cjs';
+                    redirectImportPath = redirectImportPath.replace(/\.[^.]+$/, redirectJsExtension);
+                }
             } else redirectImportPath = await addExtension(redirect, dtsFile, redirectImportPath, jsExtension, dtsExtension);
             else if (shouldAddExtension) redirectImportPath = await addExtension(redirect, dtsFile, redirectImportPath, jsExtension, dtsExtension);
             const normalizedRedirectImportPath = redirectImportPath.split(node_path.sep).join('/');
@@ -3756,6 +3774,21 @@ async function cleanDtsFiles(cwd, dir) {
             force: true
         })));
 }
+async function rewriteDtsExtensions(cwd, dir, dtsExtension, bundle, hasDeclarationMap = false) {
+    if (bundle) return;
+    const dtsFiles = await globDtsFiles(cwd, dir, [
+        '/**/*.d.ts',
+        '/**/*.d.ts.map'
+    ]);
+    await Promise.all(dtsFiles.map(async (file)=>{
+        const contents = await promises.readFile(file, 'utf8');
+        const newFileName = renameDtsFile(file, dtsExtension, bundle);
+        const newContents = updateDeclarationMapContent(file, contents, dtsExtension, bundle, hasDeclarationMap);
+        if (file === newFileName && contents === newContents) return;
+        await promises.writeFile(newFileName, newContents);
+        if (file !== newFileName) await promises.unlink(file);
+    }));
+}
 async function cleanTsBuildInfoFile(tsconfigPath, compilerOptions) {
     const tsconfigDir = dirname(tsconfigPath);
     const { outDir, rootDir, tsBuildInfoFile } = compilerOptions;
@@ -3791,4 +3824,157 @@ function updateDeclarationMapContent(fileName, content, dtsExtension, bundle, ha
     if (fileName.endsWith('.d.ts.map')) return content.replace(/("file":"[^"]*)\.d\.ts"/g, `$1${dtsExtension}"`);
     return content;
 }
-export { addBannerAndFooter, calcLongestCommonPath, cleanDtsFiles, cleanTsBuildInfoFile, clearTempDeclarationDir, color, ensureTempDeclarationDir, getDtsEmitPath, getTimeCost, globDtsFiles, loadTsconfig, mergeAliasWithTsConfigPaths, processDtsFiles, processSourceEntry, renameDtsFile, ts, updateDeclarationMapContent, warnIfOutside };
+const dts_isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj);
+const DEFAULT_EXCLUDED_PACKAGES = [
+    '@types/react'
+];
+const calcBundledPackages = (options)=>{
+    const { cwd, autoExternal, userExternals, overrideBundledPackages } = options;
+    if (overrideBundledPackages) return overrideBundledPackages;
+    let pkgJson;
+    try {
+        const content = node_fs.readFileSync(join(cwd, 'package.json'), 'utf-8');
+        pkgJson = JSON.parse(content);
+    } catch  {
+        logger.warn('The type of third-party packages will not be bundled due to read package.json failed');
+        return [];
+    }
+    const externalOptions = autoExternal ? {
+        dependencies: true,
+        peerDependencies: true,
+        optionalDependencies: true,
+        devDependencies: false,
+        ...true === autoExternal ? {} : autoExternal
+    } : {
+        dependencies: false,
+        peerDependencies: false,
+        devDependencies: false
+    };
+    const getUserExternalsKeys = (value)=>{
+        if (!value) return [];
+        if ('string' == typeof value || value instanceof RegExp) return [
+            value
+        ];
+        if (Array.isArray(value)) return value.flatMap((v)=>getUserExternalsKeys(v));
+        if (dts_isObject(userExternals)) return Object.keys(userExternals);
+        return [];
+    };
+    const externals = getUserExternalsKeys(userExternals);
+    const allDeps = [];
+    for (const type of [
+        'dependencies',
+        'peerDependencies',
+        'devDependencies'
+    ]){
+        const deps = pkgJson[type] && Object.keys(pkgJson[type]);
+        if (deps) {
+            if (externalOptions[type]) externals.push(...deps);
+            allDeps.push(...deps);
+        }
+    }
+    const bundledPackages = allDeps.filter((d)=>!externals.some((e)=>'string' == typeof e ? d === e : e.test(d)));
+    const filteredBundledPackages = Array.from(new Set(bundledPackages)).filter((pkg)=>!DEFAULT_EXCLUDED_PACKAGES.includes(pkg));
+    return filteredBundledPackages;
+};
+async function prepareDtsContext(data) {
+    const { bundle, dtsEntry, dtsEmitPath, tsconfigPath, tsConfigResult, name, cwd, build, alias = {} } = data;
+    const paths = mergeAliasWithTsConfigPaths(tsConfigResult.options.paths, alias);
+    if (Object.keys(paths).length > 0) tsConfigResult.options.paths = paths;
+    const { options: rawCompilerOptions, fileNames } = tsConfigResult;
+    const rootDir = rawCompilerOptions.rootDir ?? (rawCompilerOptions.composite ? dirname(tsconfigPath) : await calcLongestCommonPath(fileNames.filter((fileName)=>!/\.d\.(ts|mts|cts)$/.test(fileName)))) ?? dirname(tsconfigPath);
+    const resolvedDtsEmitPath = normalize(resolve(dirname(tsconfigPath), dtsEmitPath));
+    if (build) {
+        if (bundle) throw Error('Can not set "dts.bundle: true" when "dts.build: true"');
+        if ((!rawCompilerOptions.outDir || normalize(rawCompilerOptions.outDir) !== resolvedDtsEmitPath) && (!rawCompilerOptions.declarationDir || normalize(rawCompilerOptions.declarationDir) !== resolvedDtsEmitPath)) throw Error(`Please set "declarationDir": "${dtsEmitPath}" in ${color.underline(tsconfigPath)} to keep it same as "dts.distPath" or "output.distPath" field in lib config.`);
+    }
+    const declarationDir = bundle ? ensureTempDeclarationDir(cwd, name) : dtsEmitPath;
+    const bundledDtsEntries = bundle ? dtsEntry.map((entryObj)=>{
+        const { name: entryName, path: entryPath } = entryObj;
+        if (!entryPath) return null;
+        const entrySourcePath = isAbsolute(entryPath) ? entryPath : join(cwd, entryPath);
+        const relativePath = external_node_path_relative(rootDir, dirname(entrySourcePath));
+        const newPath = join(declarationDir, relativePath, basename(entrySourcePath)).replace(/\.(js|mjs|jsx|ts|mts|tsx|cjs|cts|cjsx|ctsx|mjsx|mtsx)$/, '.d.ts');
+        return {
+            name: entryName,
+            path: newPath
+        };
+    }).filter(Boolean) : [];
+    return {
+        declarationDir,
+        rootDir,
+        paths,
+        bundledDtsEntries
+    };
+}
+async function bundleDtsIfNeeded(data, context) {
+    const { bundle, name, cwd, dtsEmitPath, tsconfigPath, dtsExtension = '.d.ts', autoExternal = true, userExternals, apiExtractorOptions, banner, footer } = data;
+    if (!bundle) return;
+    const { bundledDtsEntries } = context;
+    const { bundleDts } = await import("./apiExtractor.js");
+    await bundleDts({
+        name,
+        cwd,
+        distPath: dtsEmitPath,
+        dtsEntry: bundledDtsEntries,
+        tsconfigPath,
+        dtsExtension,
+        banner,
+        footer,
+        bundledPackages: calcBundledPackages({
+            cwd,
+            autoExternal,
+            userExternals,
+            overrideBundledPackages: apiExtractorOptions?.bundledPackages
+        })
+    });
+}
+async function generateDts(data) {
+    const { bundle, tsconfigPath, tsConfigResult, name, cwd, build, isWatch, dtsExtension = '.d.ts', banner, footer, redirect = {
+        path: true,
+        extension: false
+    }, loggerLevel } = data;
+    logger.level = loggerLevel;
+    if (!isWatch) logger.start(`generating declaration files... ${color.dim(`(${name})`)}`);
+    const preparedDtsContext = await prepareDtsContext(data);
+    const { declarationDir, rootDir, paths } = preparedDtsContext;
+    const onComplete = async (isSuccess)=>{
+        if (isSuccess) try {
+            await bundleDtsIfNeeded(data, preparedDtsContext);
+        } catch (e) {
+            logger.error(e);
+        }
+    };
+    const emitDts = data.tsgo ? await import("./tsgo.js").then((mod)=>mod.emitDtsTsgo) : await import("./tsc.js").then((mod)=>mod.emitDtsTsc);
+    const hasError = await emitDts({
+        name,
+        cwd,
+        configPath: tsconfigPath,
+        tsConfigResult,
+        declarationDir,
+        dtsExtension,
+        redirect,
+        rootDir,
+        paths,
+        banner,
+        footer
+    }, onComplete, bundle, isWatch, build);
+    if (data.tsgo) {
+        if (!hasError) await bundleDtsIfNeeded(data, preparedDtsContext);
+    } else if (!isWatch) await bundleDtsIfNeeded(data, preparedDtsContext);
+}
+process.on('disconnect', ()=>{
+    process.exit();
+});
+process.on('message', async (data)=>{
+    if (!data.cwd) return;
+    try {
+        await generateDts(data);
+    } catch (e) {
+        logger.error(e);
+        process.send('error');
+        process.exit(1);
+    }
+    process.send('success');
+    if (!data.isWatch) process.exit();
+});
+export { DEFAULT_EXCLUDED_PACKAGES, addBannerAndFooter, bundleDtsIfNeeded, calcBundledPackages, cleanDtsFiles, cleanTsBuildInfoFile, clearTempDeclarationDir, color, generateDts, getDtsEmitPath, getTimeCost, loadTsconfig, prepareDtsContext, processDtsFiles, processSourceEntry, renameDtsFile, rewriteDtsExtensions, ts, updateDeclarationMapContent, warnIfOutside };

package/dist/apiExtractor.js

@@ -1,7 +1,7 @@
 import node_fs from "node:fs";
 import { join, relative } from "node:path";
 import { logger } from "@rsbuild/core";
-import { color, addBannerAndFooter, getTimeCost } from "./350.js";
+import { color, addBannerAndFooter, getTimeCost } from "./981.js";
 const logPrefixApiExtractor = color.dim('[api-extractor]');
 async function bundleDts(options) {
     let apiExtractor;

package/dist/backend.d.ts

@@ -0,0 +1,4 @@
+import type { PluginDtsOptions } from './index.js';
+export type DtsGenerationBackend = 'isolated' | 'tsc' | 'tsgo';
+export declare function validateExplicitIsolatedDtsOptions(options: Pick<PluginDtsOptions, 'isolated' | 'tsgo' | 'build' | 'abortOnError'>): void;
+export declare function resolveDtsGenerationBackend(options: Pick<PluginDtsOptions, 'isolated' | 'tsgo' | 'build' | 'abortOnError'>): DtsGenerationBackend;

package/dist/dts.d.ts

@@ -1,4 +1,4 @@
-import type { DtsGenOptions } from './index.js';
+import type { DtsEntry, DtsGenOptions } from './index.js';
 export declare const DEFAULT_EXCLUDED_PACKAGES: string[];
 type CalculateBundledPackagesOptions = {
     cwd: string;
@@ -7,5 +7,13 @@ type CalculateBundledPackagesOptions = {
     overrideBundledPackages?: string[];
 };
 export declare const calcBundledPackages: (options: CalculateBundledPackagesOptions) => string[];
+export type PreparedDtsContext = {
+    declarationDir: string;
+    rootDir: string;
+    paths: Record<string, string[]>;
+    bundledDtsEntries: Required<DtsEntry>[];
+};
+export declare function prepareDtsContext(data: DtsGenOptions): Promise<PreparedDtsContext>;
+export declare function bundleDtsIfNeeded(data: DtsGenOptions, context: Pick<PreparedDtsContext, 'bundledDtsEntries'>): Promise<void>;
 export declare function generateDts(data: DtsGenOptions): Promise<void>;
 export {};

package/dist/dts.js

@@ -1,147 +1 @@
-import node_fs from "node:fs";
-import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
-import { logger } from "@rsbuild/core";
-import { ensureTempDeclarationDir, color, calcLongestCommonPath, mergeAliasWithTsConfigPaths } from "./350.js";
-const isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj);
-const DEFAULT_EXCLUDED_PACKAGES = [
-    '@types/react'
-];
-const calcBundledPackages = (options)=>{
-    const { cwd, autoExternal, userExternals, overrideBundledPackages } = options;
-    if (overrideBundledPackages) return overrideBundledPackages;
-    let pkgJson;
-    try {
-        const content = node_fs.readFileSync(join(cwd, 'package.json'), 'utf-8');
-        pkgJson = JSON.parse(content);
-    } catch  {
-        logger.warn('The type of third-party packages will not be bundled due to read package.json failed');
-        return [];
-    }
-    const externalOptions = autoExternal ? {
-        dependencies: true,
-        peerDependencies: true,
-        optionalDependencies: true,
-        devDependencies: false,
-        ...true === autoExternal ? {} : autoExternal
-    } : {
-        dependencies: false,
-        peerDependencies: false,
-        devDependencies: false
-    };
-    const getUserExternalsKeys = (value)=>{
-        if (!value) return [];
-        if ('string' == typeof value || value instanceof RegExp) return [
-            value
-        ];
-        if (Array.isArray(value)) return value.flatMap((v)=>getUserExternalsKeys(v));
-        if (isObject(userExternals)) return Object.keys(userExternals);
-        return [];
-    };
-    const externals = getUserExternalsKeys(userExternals);
-    const allDeps = [];
-    for (const type of [
-        'dependencies',
-        'peerDependencies',
-        'devDependencies'
-    ]){
-        const deps = pkgJson[type] && Object.keys(pkgJson[type]);
-        if (deps) {
-            if (externalOptions[type]) externals.push(...deps);
-            allDeps.push(...deps);
-        }
-    }
-    const bundledPackages = allDeps.filter((d)=>!externals.some((e)=>'string' == typeof e ? d === e : e.test(d)));
-    const filteredBundledPackages = Array.from(new Set(bundledPackages)).filter((pkg)=>!DEFAULT_EXCLUDED_PACKAGES.includes(pkg));
-    return filteredBundledPackages;
-};
-async function generateDts(data) {
-    const { bundle, dtsEntry, dtsEmitPath, tsconfigPath, tsConfigResult, name, cwd, build, isWatch, dtsExtension = '.d.ts', autoExternal = true, alias = {}, userExternals, apiExtractorOptions, banner, footer, redirect = {
-        path: true,
-        extension: false
-    }, tsgo, loggerLevel } = data;
-    logger.level = loggerLevel;
-    if (!isWatch) logger.start(`generating declaration files... ${color.dim(`(${name})`)}`);
-    const paths = mergeAliasWithTsConfigPaths(tsConfigResult.options.paths, alias);
-    if (Object.keys(paths).length > 0) tsConfigResult.options.paths = paths;
-    const { options: rawCompilerOptions, fileNames } = tsConfigResult;
-    const rootDir = rawCompilerOptions.rootDir ?? (rawCompilerOptions.composite ? dirname(tsconfigPath) : await calcLongestCommonPath(fileNames.filter((fileName)=>!/\.d\.(ts|mts|cts)$/.test(fileName)))) ?? dirname(tsconfigPath);
-    const resolvedDtsEmitPath = normalize(resolve(dirname(tsconfigPath), dtsEmitPath));
-    if (build) {
-        if (bundle) throw Error('Can not set "dts.bundle: true" when "dts.build: true"');
-        if ((!rawCompilerOptions.outDir || normalize(rawCompilerOptions.outDir) !== resolvedDtsEmitPath) && (!rawCompilerOptions.declarationDir || normalize(rawCompilerOptions.declarationDir) !== resolvedDtsEmitPath)) throw Error(`Please set "declarationDir": "${dtsEmitPath}" in ${color.underline(tsconfigPath)} to keep it same as "dts.distPath" or "output.distPath" field in lib config.`);
-    }
-    const declarationDir = bundle ? ensureTempDeclarationDir(cwd, name) : dtsEmitPath;
-    let dtsEntries = [];
-    if (bundle) dtsEntries = dtsEntry.map((entryObj)=>{
-        const { name: entryName, path: entryPath } = entryObj;
-        if (!entryPath) return null;
-        const entrySourcePath = isAbsolute(entryPath) ? entryPath : join(cwd, entryPath);
-        const relativePath = relative(rootDir, dirname(entrySourcePath));
-        const newPath = join(declarationDir, relativePath, basename(entrySourcePath)).replace(/\.(js|mjs|jsx|ts|mts|tsx|cjs|cts|cjsx|ctsx|mjsx|mtsx)$/, '.d.ts');
-        return {
-            name: entryName,
-            path: newPath
-        };
-    }).filter(Boolean);
-    const bundleDtsIfNeeded = async ()=>{
-        if (bundle) {
-            const { bundleDts } = await import("./apiExtractor.js");
-            await bundleDts({
-                name,
-                cwd,
-                distPath: dtsEmitPath,
-                dtsEntry: dtsEntries,
-                tsconfigPath,
-                dtsExtension,
-                banner,
-                footer,
-                bundledPackages: calcBundledPackages({
-                    cwd,
-                    autoExternal,
-                    userExternals,
-                    overrideBundledPackages: apiExtractorOptions?.bundledPackages
-                })
-            });
-        }
-    };
-    const onComplete = async (isSuccess)=>{
-        if (isSuccess) try {
-            await bundleDtsIfNeeded();
-        } catch (e) {
-            logger.error(e);
-        }
-    };
-    const emitDts = tsgo ? await import("./tsgo.js").then((mod)=>mod.emitDtsTsgo) : await import("./tsc.js").then((mod)=>mod.emitDtsTsc);
-    const hasError = await emitDts({
-        name,
-        cwd,
-        configPath: tsconfigPath,
-        tsConfigResult,
-        declarationDir,
-        dtsExtension,
-        redirect,
-        rootDir,
-        paths,
-        banner,
-        footer
-    }, onComplete, bundle, isWatch, build);
-    if (tsgo) {
-        if (!hasError) await bundleDtsIfNeeded();
-    } else if (!isWatch) await bundleDtsIfNeeded();
-}
-process.on('disconnect', ()=>{
-    process.exit();
-});
-process.on('message', async (data)=>{
-    if (!data.cwd) return;
-    try {
-        await generateDts(data);
-    } catch (e) {
-        logger.error(e);
-        process.send('error');
-        process.exit(1);
-    }
-    process.send('success');
-    if (!data.isWatch) process.exit();
-});
-export { DEFAULT_EXCLUDED_PACKAGES, calcBundledPackages, generateDts };
+export { DEFAULT_EXCLUDED_PACKAGES, bundleDtsIfNeeded, calcBundledPackages, generateDts, prepareDtsContext } from "./981.js";

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export type PluginDtsOptions = {
     abortOnError?: boolean;
     dtsExtension?: string;
     alias?: Record<string, string>;
+    isolated?: boolean;
     autoExternal?: boolean | {
         dependencies?: boolean;
         optionalDependencies?: boolean;
@@ -29,7 +30,7 @@ export type DtsEntry = {
     name: string;
     path: string;
 };
-export type DtsGenOptions = Omit<PluginDtsOptions, 'bundle'> & {
+export type DtsGenOptions = Omit<PluginDtsOptions, 'bundle' | 'isolated'> & {
     bundle: boolean;
     name: string;
     cwd: string;

package/dist/index.js

@@ -1,7 +1,59 @@
 import { fork } from "node:child_process";
-import { extname, join } from "node:path";
-import { logger } from "@rsbuild/core";
-import { processSourceEntry, cleanDtsFiles, clearTempDeclarationDir, getDtsEmitPath, cleanTsBuildInfoFile, color, warnIfOutside, ts, loadTsconfig } from "./350.js";
+import { extname, join, normalize, resolve as external_node_path_resolve } from "node:path";
+import { logger, rspack } from "@rsbuild/core";
+import { loadTsconfig, processSourceEntry, bundleDtsIfNeeded, cleanDtsFiles, getDtsEmitPath, rewriteDtsExtensions, clearTempDeclarationDir, cleanTsBuildInfoFile, color, prepareDtsContext, warnIfOutside, ts, processDtsFiles } from "./981.js";
+const applyIsolatedDtsOptions = (isolatedDtsContext)=>{
+    const bundlerConfig = isolatedDtsContext.bundlerConfig;
+    const RspackRslibPlugin = rspack.experiments.RslibPlugin;
+    const rslibPlugin = bundlerConfig?.plugins?.find((plugin)=>plugin instanceof RspackRslibPlugin);
+    if (!rslibPlugin?._args?.[0]) throw new Error('Can not enable "dts.isolated: true" without the built-in RslibPlugin.');
+    const emitDts = {
+        rootDir: normalize(external_node_path_resolve(isolatedDtsContext.cwd, isolatedDtsContext.rootDir)),
+        declarationDir: normalize(external_node_path_resolve(isolatedDtsContext.cwd, isolatedDtsContext.declarationDir))
+    };
+    rslibPlugin._args[0].emitDts = emitDts;
+    if (rslibPlugin._args[0].emitDts !== emitDts) throw new Error('Failed to configure Rspack isolated declaration emission.');
+};
+async function createIsolatedDtsContext(dtsGenOptions, bundlerConfig) {
+    const isolatedDtsContext = {
+        ...dtsGenOptions,
+        dtsExtension: dtsGenOptions.dtsExtension ?? '.d.ts',
+        bundlerConfig,
+        ...await prepareDtsContext(dtsGenOptions)
+    };
+    applyIsolatedDtsOptions(isolatedDtsContext);
+    return isolatedDtsContext;
+}
+async function processIsolatedDts(isolatedDtsContext, options = {}) {
+    const { logSuccess = true } = options;
+    await rewriteDtsExtensions(isolatedDtsContext.cwd, isolatedDtsContext.declarationDir, isolatedDtsContext.dtsExtension, isolatedDtsContext.bundle, isolatedDtsContext.tsConfigResult.options.declarationMap);
+    await processDtsFiles(isolatedDtsContext.bundle, isolatedDtsContext.cwd, isolatedDtsContext.declarationDir, isolatedDtsContext.dtsExtension, isolatedDtsContext.redirect ?? {
+        path: true,
+        extension: false
+    }, isolatedDtsContext.tsconfigPath, isolatedDtsContext.rootDir, isolatedDtsContext.paths, isolatedDtsContext.banner, isolatedDtsContext.footer);
+    if (!logSuccess) return;
+    if (isolatedDtsContext.bundle) {
+        if (!isolatedDtsContext.isWatch) logger.info(`declaration files prepared with isolated declaration ${color.dim(`(${isolatedDtsContext.name})`)}`);
+        try {
+            await bundleDtsIfNeeded(isolatedDtsContext, isolatedDtsContext);
+        } catch (error) {
+            if (!isolatedDtsContext.isWatch) throw error;
+            logger.error(error);
+        }
+    } else if (!isolatedDtsContext.isWatch) logger.ready(`declaration files generated with isolated declaration ${color.dim(`(${isolatedDtsContext.name})`)}`);
+}
+function validateExplicitIsolatedDtsOptions(options) {
+    if (true !== options.isolated) return;
+    if (options.tsgo) throw new Error('Can not set "dts.isolated: true" when "dts.tsgo: true".');
+    if (options.build) throw new Error('Can not set "dts.isolated: true" when "dts.build: true".');
+    if (false === options.abortOnError) throw new Error('Can not set "dts.abortOnError: false" when "dts.isolated: true".');
+}
+function resolveDtsGenerationBackend(options) {
+    validateExplicitIsolatedDtsOptions(options);
+    if (true === options.isolated) return 'isolated';
+    if (options.tsgo) return 'tsgo';
+    return 'tsc';
+}
 const PLUGIN_DTS_NAME = 'rsbuild:dts';
 const pluginDts = (options = {})=>({
         name: PLUGIN_DTS_NAME,
@@ -25,8 +77,25 @@ const pluginDts = (options = {})=>({
             });
             let promiseResult;
             let childProcesses = [];
-            api.onBeforeEnvironmentCompile(async ({ isWatch, isFirstCompile, environment })=>{
-                if (!isFirstCompile && !options.tsgo) return;
+            const dtsBackend = resolveDtsGenerationBackend(options);
+            let dtsGenOptions;
+            let isolatedDtsContext;
+            api.modifyEnvironmentConfig((config, { mergeEnvironmentConfig })=>{
+                if (true !== options.isolated) return;
+                return mergeEnvironmentConfig(config, {
+                    tools: {
+                        swc: {
+                            jsc: {
+                                experimental: {
+                                    emitIsolatedDts: true
+                                }
+                            }
+                        }
+                    }
+                });
+            });
+            api.onBeforeEnvironmentCompile(async ({ isWatch, isFirstCompile, environment, bundlerConfig })=>{
+                if ('tsc' === dtsBackend && !isFirstCompile) return;
                 const { config } = environment;
                 const dtsEntry = processSourceEntry(bundle, config.source?.entry);
                 const cwd = api.context.rootPath;
@@ -45,13 +114,8 @@ const pluginDts = (options = {})=>({
                 warnIfOutside(cwd, outDir, 'outDir');
                 if (false !== config.output.cleanDistPath) await cleanDtsFiles(cwd, dtsEmitPath);
                 if (bundle) await clearTempDeclarationDir(cwd);
-                if (composite || incremental || options.build) await cleanTsBuildInfoFile(tsconfigPath, rawCompilerOptions);
-                const jsExtension = extname(import.meta.filename);
-                const childProcess = fork(join(import.meta.dirname, `./dts${jsExtension}`), [], {
-                    stdio: 'inherit'
-                });
-                childProcesses.push(childProcess);
-                const dtsGenOptions = {
+                if ('isolated' !== dtsBackend && (composite || incremental || options.build)) await cleanTsBuildInfoFile(tsconfigPath, rawCompilerOptions);
+                dtsGenOptions = {
                     ...options,
                     bundle,
                     dtsEntry,
@@ -65,6 +129,18 @@ const pluginDts = (options = {})=>({
                     isWatch,
                     loggerLevel: loggerLevel
                 };
+                if ('isolated' === dtsBackend) {
+                    isolatedDtsContext = await createIsolatedDtsContext(dtsGenOptions, bundlerConfig);
+                    dtsPromise = Promise.resolve({
+                        status: 'success'
+                    });
+                    return;
+                }
+                const jsExtension = extname(import.meta.filename);
+                const childProcess = fork(join(import.meta.dirname, `./dts${jsExtension}`), [], {
+                    stdio: 'inherit'
+                });
+                childProcesses.push(childProcess);
                 childProcess.send(dtsGenOptions);
                 dtsPromise = new Promise((resolve)=>{
                     childProcess.on('message', (message)=>{
@@ -79,14 +155,31 @@ const pluginDts = (options = {})=>({
                 });
             });
             api.onAfterBuild({
-                handler: async ({ isFirstCompile })=>{
-                    if (!isFirstCompile) return;
+                handler: async ({ isFirstCompile, stats })=>{
+                    if ('tsc' === dtsBackend && !isFirstCompile) return;
+                    if (isolatedDtsContext) {
+                        try {
+                            await processIsolatedDts(isolatedDtsContext, {
+                                logSuccess: !stats?.hasErrors()
+                            });
+                            promiseResult = {
+                                status: 'success'
+                            };
+                        } catch (error) {
+                            logger.error(error);
+                            promiseResult = {
+                                status: 'error',
+                                errorMessage: `Error occurred in ${isolatedDtsContext.name} declaration files generation.`
+                            };
+                        }
+                        return;
+                    }
                     promiseResult = await dtsPromise;
                 },
                 order: 'pre'
             });
             api.onAfterBuild(({ isFirstCompile })=>{
-                if (!isFirstCompile) return;
+                if ('tsc' === dtsBackend && !isFirstCompile) return;
                 if ('error' === promiseResult.status) {
                     if (options.abortOnError) {
                         const error = new Error(promiseResult.errorMessage);

package/dist/isolated.d.ts

@@ -0,0 +1,11 @@
+import type { Rspack } from '@rsbuild/core';
+import { type PreparedDtsContext } from './dts.js';
+import type { DtsGenOptions } from './index.js';
+export type IsolatedDtsContext = Omit<DtsGenOptions, 'dtsExtension'> & PreparedDtsContext & {
+    dtsExtension: string;
+    bundlerConfig: Rspack.Configuration | undefined;
+};
+export declare function createIsolatedDtsContext(dtsGenOptions: DtsGenOptions, bundlerConfig: Rspack.Configuration | undefined): Promise<IsolatedDtsContext>;
+export declare function processIsolatedDts(isolatedDtsContext: IsolatedDtsContext, options?: {
+    logSuccess?: boolean;
+}): Promise<void>;

package/dist/tsc.js

@@ -1,5 +1,5 @@
 import { logger } from "@rsbuild/core";
-import { updateDeclarationMapContent, processDtsFiles, color, renameDtsFile, ts, getTimeCost } from "./350.js";
+import { updateDeclarationMapContent, processDtsFiles, color, renameDtsFile, ts, getTimeCost } from "./981.js";
 const logPrefixTsc = color.dim('[tsc]');
 const formatHost = {
     getCanonicalFileName: (path)=>path,

package/dist/tsgo.js

@@ -1,10 +1,9 @@
 import { spawn } from "node:child_process";
-import promises from "node:fs/promises";
 import { createRequire } from "node:module";
 import node_path from "node:path";
 import { pathToFileURL } from "node:url";
 import { logger } from "@rsbuild/core";
-import { updateDeclarationMapContent, processDtsFiles, color, renameDtsFile, globDtsFiles, getTimeCost } from "./350.js";
+import { processDtsFiles, color, rewriteDtsExtensions, getTimeCost } from "./981.js";
 const tsgo_require = createRequire(import.meta.url);
 const logPrefixTsgo = color.dim('[tsgo]');
 const getTsgoBinPath = async ()=>{
@@ -30,21 +29,7 @@ const generateTsgoArgs = (configPath, declarationDir, build, isWatch)=>{
     return args;
 };
 async function handleDiagnosticsAndProcessFiles(isWatch, hasErrors, tsConfigResult, configPath, bundle, cwd, declarationDir, dtsExtension, redirect, rootDir, paths, banner, footer, name) {
-    if (!bundle) {
-        const dtsFiles = await globDtsFiles(cwd, declarationDir, [
-            '/**/*.d.ts',
-            '/**/*.d.ts.map'
-        ]);
-        await Promise.all(dtsFiles.map(async (file)=>{
-            const contents = await promises.readFile(file, 'utf8');
-            const newFileName = renameDtsFile(file, dtsExtension, bundle);
-            const newContents = updateDeclarationMapContent(file, contents, dtsExtension, bundle, tsConfigResult.options.declarationMap);
-            if (file !== newFileName || contents !== newContents) {
-                await promises.writeFile(newFileName, newContents);
-                await promises.unlink(file);
-            }
-        }));
-    }
+    await rewriteDtsExtensions(cwd, declarationDir, dtsExtension, bundle, tsConfigResult.options.declarationMap);
     await processDtsFiles(bundle, cwd, declarationDir, dtsExtension, redirect, configPath, rootDir, paths, banner, footer);
     if (hasErrors && !isWatch) {
         const error = new Error(`Failed to generate declaration files. ${color.dim(`(${name})`)}`);

package/dist/utils.d.ts

@@ -32,6 +32,7 @@ export declare function processSourceEntry(bundle: boolean, entryConfig: NonNull
 export declare function calcLongestCommonPath(absPaths: string[]): Promise<string | null>;
 export declare const globDtsFiles: (cwd: string, dir: string, patterns: string[]) => Promise<string[]>;
 export declare function cleanDtsFiles(cwd: string, dir: string): Promise<void>;
+export declare function rewriteDtsExtensions(cwd: string, dir: string, dtsExtension: string, bundle: boolean, hasDeclarationMap?: boolean): Promise<void>;
 export declare function cleanTsBuildInfoFile(tsconfigPath: string, compilerOptions: CompilerOptions): Promise<void>;
 export declare function getDtsEmitPath(pathFromPlugin: string | undefined, declarationDir: string | undefined, distPathRoot: string): string;
 export declare function warnIfOutside(cwd: string, dir: string | undefined, label: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rsbuild-plugin-dts",
-  "version": "0.21.5",
+  "version": "0.22.0",
   "description": "Rsbuild plugin that supports emitting declaration files for TypeScript.",
   "homepage": "https://rslib.rs",
   "bugs": {
@@ -30,12 +30,12 @@
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.58.7",
-    "@rsbuild/core": "~2.0.6",
-    "@typescript/native-preview": "7.0.0-dev.20260512.1",
+    "@rsbuild/core": "~2.0.8",
+    "@typescript/native-preview": "7.0.0-dev.20260527.2",
     "magic-string": "^0.30.21",
     "prebundle": "1.6.4",
-    "rsbuild-plugin-publint": "^0.3.4",
-    "rslib": "npm:@rslib/core@0.21.4",
+    "rsbuild-plugin-publint": "^1.0.0",
+    "rslib": "npm:@rslib/core@0.21.5",
     "tinyglobby": "^0.2.16",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^6.0.3",