fix: merge conflict

Author: 9aoy

.changeset/smooth-parents-pull.md

@@ -0,0 +1,5 @@
+---
+'@rslib/core': patch
+---
+
+fix: the moduleIds should be deterministic if the env is production and format is mf

.gitignore

@@ -11,6 +11,8 @@ coverage/
 doc_build/
 playwright-report/
 tsconfig.tsbuildinfo
+tsconfig.esm.tsbuildinfo
+tsconfig.cjs.tsbuildinfo
 test-temp-*
 test-results
 

packages/core/src/cli/mf.ts

@@ -44,6 +44,7 @@ function changeEnvToDev(rsbuildConfig: RsbuildConfig) {
       rspack: {
         optimization: {
           nodeEnv: 'development',
+          moduleIds: 'named',
         },
       },
     },

packages/core/src/config.ts

@@ -597,9 +597,9 @@ const composeFormatConfig = ({
             },
             // can not set nodeEnv to false, because mf format should build shared module.
             // If nodeEnv is false, the process.env.NODE_ENV in third-party packages's will not be replaced
-            // now we have not provide dev mode for users, so we can always set nodeEnv as 'production'
             optimization: {
               nodeEnv: 'production',
+              moduleIds: 'deterministic',
             },
           },
         },

packages/plugin-dts/src/apiExtractor.ts

@@ -52,9 +52,7 @@ export async function bundleDts(options: BundleOptions): Promise<void> {
         untrimmedFilePath,
       },
       compiler: {
-        tsconfigFilePath: tsconfigPath.includes(cwd)
-          ? tsconfigPath
-          : join(cwd, tsconfigPath),
+        tsconfigFilePath: tsconfigPath,
       },
       projectFolder: cwd,
     };

packages/plugin-dts/src/dts.ts

@@ -10,14 +10,9 @@ import {
 } from 'node:path';
 import { logger } from '@rsbuild/core';
 import color from 'picocolors';
-import ts from 'typescript';
 import type { DtsGenOptions } from './index';
 import { emitDts } from './tsc';
-import {
-  calcLongestCommonPath,
-  ensureTempDeclarationDir,
-  loadTsconfig,
-} from './utils';
+import { calcLongestCommonPath, ensureTempDeclarationDir } from './utils';
 
 const isObject = (obj: unknown): obj is Record<string, any> =>
   Object.prototype.toString.call(obj) === '[object Object]';
@@ -113,9 +108,10 @@ export const calcBundledPackages = (options: {
 export async function generateDts(data: DtsGenOptions): Promise<void> {
   const {
     bundle,
-    distPath,
+    dtsEmitPath,
     dtsEntry,
     tsconfigPath,
+    tsConfigResult,
     name,
     cwd,
     build,
@@ -125,33 +121,25 @@ export async function generateDts(data: DtsGenOptions): Promise<void> {
     userExternals,
     banner,
     footer,
-    rootDistPath,
   } = data;
   logger.start(`Generating DTS... ${color.gray(`(${name})`)}`);
-  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
-  if (!configPath) {
-    logger.error(`tsconfig.json not found in ${cwd}`);
-    throw new Error();
-  }
-  const { options: rawCompilerOptions, fileNames } = loadTsconfig(configPath);
+
+  const { options: rawCompilerOptions, fileNames } = tsConfigResult;
 
   // The longest common path of all non-declaration input files.
   // If composite is set, the default is instead the directory containing the tsconfig.json file.
   // see https://www.typescriptlang.org/tsconfig/#rootDir
   const rootDir =
     rawCompilerOptions.rootDir ??
     (rawCompilerOptions.composite
-      ? dirname(configPath)
+      ? dirname(tsconfigPath)
       : await calcLongestCommonPath(
           fileNames.filter((fileName) => !/\.d\.(ts|mts|cts)$/.test(fileName)),
         )) ??
-    dirname(configPath);
-
-  const dtsEmitPath =
-    distPath ?? rawCompilerOptions.declarationDir ?? rootDistPath;
+    dirname(tsconfigPath);
 
   const resolvedDtsEmitPath = normalize(
-    resolve(dirname(configPath), dtsEmitPath),
+    resolve(dirname(tsconfigPath), dtsEmitPath),
   );
 
   if (build) {
@@ -173,13 +161,15 @@ export async function generateDts(data: DtsGenOptions): Promise<void> {
           : 'declarationDir';
       throw Error(
         `Please set ${info}: "${dtsEmitPath}" in ${color.underline(
-          configPath,
+          tsconfigPath,
         )} to keep it same as "dts.distPath" or "output.distPath.root" field in lib config.`,
       );
     }
   }
 
-  const declarationDir = bundle ? ensureTempDeclarationDir(cwd) : dtsEmitPath;
+  const declarationDir = bundle
+    ? ensureTempDeclarationDir(cwd, name)
+    : dtsEmitPath;
 
   const { name: entryName, path: entryPath } = dtsEntry;
   let entry = '';
@@ -232,7 +222,8 @@ export async function generateDts(data: DtsGenOptions): Promise<void> {
     {
       name,
       cwd,
-      configPath,
+      configPath: tsconfigPath,
+      tsConfigResult,
       declarationDir,
       dtsExtension,
       banner,

packages/plugin-dts/src/index.ts

@@ -2,7 +2,14 @@ import { type ChildProcess, fork } from 'node:child_process';
 import { dirname, extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { type RsbuildConfig, type RsbuildPlugin, logger } from '@rsbuild/core';
-import { processSourceEntry } from './utils';
+import ts from 'typescript';
+import {
+  cleanDtsFiles,
+  cleanTsBuildInfoFile,
+  clearTempDeclarationDir,
+  loadTsconfig,
+  processSourceEntry,
+} from './utils';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -34,9 +41,10 @@ export type DtsGenOptions = PluginDtsOptions & {
   cwd: string;
   isWatch: boolean;
   dtsEntry: DtsEntry;
-  rootDistPath: string;
+  dtsEmitPath: string;
   build?: boolean;
-  tsconfigPath?: string;
+  tsconfigPath: string;
+  tsConfigResult: ts.ParsedCommandLine;
   userExternals?: NonNullable<RsbuildConfig['output']>['externals'];
 };
 
@@ -63,35 +71,69 @@ export const pluginDts = (options: PluginDtsOptions = {}): RsbuildPlugin => ({
     let childProcesses: ChildProcess[] = [];
 
     api.onBeforeEnvironmentCompile(
-      ({ isWatch, isFirstCompile, environment }) => {
+      async ({ isWatch, isFirstCompile, environment }) => {
         if (!isFirstCompile) {
           return;
         }
 
         const { config } = environment;
 
+        // TODO: @microsoft/api-extractor only support single entry to bundle DTS
+        // use first element of Record<string, string> type entry config
+        const dtsEntry = processSourceEntry(
+          options.bundle!,
+          config.source?.entry,
+        );
+
+        const cwd = api.context.rootPath;
+        const tsconfigPath = ts.findConfigFile(
+          cwd,
+          ts.sys.fileExists,
+          config.source.tsconfigPath,
+        );
+
+        if (!tsconfigPath) {
+          logger.error(`tsconfig.json not found in ${cwd}`);
+          throw new Error();
+        }
+
+        const tsConfigResult = loadTsconfig(tsconfigPath);
+        const dtsEmitPath =
+          options.distPath ??
+          tsConfigResult.options.declarationDir ??
+          config.output?.distPath?.root;
+
         const jsExtension = extname(__filename);
         const childProcess = fork(join(__dirname, `./dts${jsExtension}`), [], {
           stdio: 'inherit',
         });
 
         childProcesses.push(childProcess);
 
-        // TODO: @microsoft/api-extractor only support single entry to bundle DTS
-        // use first element of Record<string, string> type entry config
-        const dtsEntry = processSourceEntry(
-          options.bundle!,
-          config.source?.entry,
-        );
+        const { cleanDistPath } = config.output;
+
+        // clean dts files
+        if (cleanDistPath !== false) {
+          await cleanDtsFiles(dtsEmitPath);
+        }
+
+        // clean .rslib temp folder
+        if (options.bundle) {
+          await clearTempDeclarationDir(cwd);
+        }
+
+        // clean tsbuildinfo file
+        await cleanTsBuildInfoFile(tsconfigPath, tsConfigResult);
 
         const dtsGenOptions: DtsGenOptions = {
           ...options,
           dtsEntry,
+          dtsEmitPath,
           userExternals: config.output.externals,
-          rootDistPath: config.output?.distPath?.root,
-          tsconfigPath: config.source.tsconfigPath,
+          tsconfigPath,
+          tsConfigResult,
           name: environment.name,
-          cwd: api.context.rootPath,
+          cwd,
           isWatch,
         };
 

packages/plugin-dts/src/tsc.ts

@@ -1,17 +1,13 @@
 import { logger } from '@rsbuild/core';
 import color from 'picocolors';
 import ts from 'typescript';
-import {
-  getFileLoc,
-  getTimeCost,
-  loadTsconfig,
-  processDtsFiles,
-} from './utils';
+import { getFileLoc, getTimeCost, processDtsFiles } from './utils';
 
 export type EmitDtsOptions = {
   name: string;
   cwd: string;
   configPath: string;
+  tsConfigResult: ts.ParsedCommandLine;
   declarationDir: string;
   dtsExtension: string;
   banner?: string;
@@ -63,14 +59,20 @@ export async function emitDts(
   build = false,
 ): Promise<void> {
   const start = Date.now();
-  const { configPath, declarationDir, name, dtsExtension, banner, footer } =
-    options;
-  const configFileParseResult = loadTsconfig(configPath);
+  const {
+    configPath,
+    tsConfigResult,
+    declarationDir,
+    name,
+    dtsExtension,
+    banner,
+    footer,
+  } = options;
   const {
     options: rawCompilerOptions,
     fileNames,
     projectReferences,
-  } = configFileParseResult;
+  } = tsConfigResult;
 
   const compilerOptions = {
     ...rawCompilerOptions,
@@ -160,9 +162,8 @@ export async function emitDts(
         options: compilerOptions,
         projectReferences,
         host,
-        configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(
-          configFileParseResult,
-        ),
+        configFileParsingDiagnostics:
+          ts.getConfigFileParsingDiagnostics(tsConfigResult),
       });
 
       const emitResult = program.emit();
@@ -190,9 +191,8 @@ export async function emitDts(
       const program = ts.createIncrementalProgram({
         rootNames: fileNames,
         options: compilerOptions,
-        configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(
-          configFileParseResult,
-        ),
+        configFileParsingDiagnostics:
+          ts.getConfigFileParsingDiagnostics(tsConfigResult),
         projectReferences,
         host,
         createProgram,