Support tsconfig RootDirs

[tpavlu]

Support TypeScript rootDirs Configuration

Problem Statement

Generated code often lives alongside source code in separate directory structures:

src/
  a/foo.ts
generated/
  b/bar.d.ts
  c/d/moo.ts  # Generated TypeScript files (not just .d.ts)

The issue:

• TypeScript's type checking works perfectly with rootDirs configuration
• Rspack/Rsbuild cannot resolve relative imports across these root directories
• This creates a mismatch between type checking and bundling behavior

Current broken behavior:

• From src/a/foo.ts, this import fails during build:

  import { something } from '../c/d/moo'  // ❌ Cannot resolve

• TypeScript understands this import perfectly when rootDirs: ["src", "generated"] is configured
• Build fails despite passing type checking

Attempted Workarounds

1. Using resolve.modules (Partial Solution)

{
  resolve: {
    modules: [path.resolve(root, 'src'), path.resolve(root, 'generated')]
  }
}

Limitation: Only works for absolute imports, not relative paths like './c/moo'.

2. Custom Plugin (Working but Complex)

compiler.hooks.normalModuleFactory.tap('RootDirsPlugin', (nmf) => {
  nmf.hooks.resolve.tap('RootDirsPlugin', (data: ResolveData<unknown>) => {
    // Rewrite import requests to absolute paths
  });
});

Works but: Requires custom plugin code for what should be standard TypeScript behavior.

3. Webpack resolve.plugins (Not Available)

This worked in Webpack but resolve.plugins are not supported by Rsbuild.

Proposed Solution

Add native support for TypeScript's rootDirs configuration, similar to how paths is currently handled.

Expected Behavior

When tsconfig.json contains:

{
  "compilerOptions": {
    "rootDirs": ["src", "generated"]
  }
}

Rspack/Rsbuild should automatically resolve relative imports across all root directories, making these equivalent:

// From src/a/foo.ts, these should both work:
import { moo } from '../c/d/moo'     // Resolves to generated/c/d/moo.ts
import { moo } from './sibling'     // Resolves to src/a/sibling.ts

Why This Makes Sense

1. Consistency: Rspack already reads tsconfig for paths - rootDirs is a natural extension
2. Common Use Case: Generated code patterns are increasingly common (GraphQL codegen, Protocol Buffers, etc.)
3. TypeScript Alignment: Reduces impedance mismatch between type checking and bundling
4. Developer Experience: Eliminates need for complex workarounds or custom plugins

Implementation Notes

• Should follow the same patterns as existing paths support
• Need to handle relative path resolution across multiple root directories
• Consider file precedence when same relative path exists in multiple roots (TypeScript uses first match)

---

This feature would eliminate a significant pain point for projects using generated code patterns while maintaining consistency with existing TypeScript configuration support.