@rsbuild/core 2.0.12 → 2.0.14

package/dist/756.js

@@ -3483,7 +3483,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig, logger) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.12",
+        version: "2.0.14",
         rootPath,
         distPath: '',
         cachePath,
@@ -5868,6 +5868,14 @@ async function open_open({ port, routes, config, protocol, clearCache, logger })
     let urls = [], host = await getHostInUrl(config.server.host), baseUrl = `${protocol}://${host}:${port}`;
     for (let url of (targets.length ? urls.push(...targets.map((target)=>resolveUrl(replacePortPlaceholder(target, port), baseUrl))) : routes.length ? urls.push(`${baseUrl}${routes[0].pathname}`) : urls.push(baseUrl), before && await before(), urls))openedURLs.includes(url) || (openBrowser(url, logger), openedURLs.push(url));
 }
+let getServerUrlFromClientConfig = async (config, context)=>{
+    let { devServer } = context;
+    if (!devServer) return;
+    let { client } = config.dev, hasClientHost = !!client.host, hasClientPort = void 0 !== client.port && '' !== client.port;
+    if (!hasClientHost && !hasClientPort) return;
+    let protocol = client.protocol ? `${'wss' === client.protocol ? 'https' : 'http'}:` : '', hostname = await getHostInUrl(client.host || devServer.hostname), port = client.port && '<port>' !== client.port ? client.port : devServer.port;
+    return `${protocol}//${hostname}:${port}`;
+};
 function recursiveChunkGroup(chunkGroup, visited = new Set()) {
     if (visited.has(chunkGroup)) return [];
     visited.add(chunkGroup);
@@ -7335,7 +7343,12 @@ async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls,
         rl.close();
     };
 }
-let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i;
+let createDeferred = ()=>{
+    let deferred = {};
+    return deferred.promise = new Promise((resolve)=>{
+        deferred.resolve = resolve;
+    }), deferred;
+}, ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i;
 function gzipMiddleware_gzipMiddleware({ filter, level = node_zlib.constants.Z_BEST_SPEED } = {}) {
     return function gzipMiddleware(req, res, next) {
         let gzip, writeHeadStatus, writeHeadMessage;
@@ -8057,7 +8070,8 @@ async function startWatchFiles({ paths, options, type = 'reload-page' }, buildMa
     }), watcher;
 }
 async function devServer_createDevServer(options, createCompiler, config, { getPortSilently, runCompile = !0 } = {}) {
-    let lastStats, { context } = options, { logger } = context;
+    var environmentCount;
+    let stats, waiters, { context } = options, { logger } = context;
     logger.debug('create dev server');
     let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, routes = getRoutes(context), fallbackPathname = 0 === routes.length && context.environmentList.some((item)=>'web' === item.config.output.target) ? config.server.base : void 0;
     context.devServer = {
@@ -8065,24 +8079,40 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
         port,
         https: isHttps
     };
-    let waitLastCompileDoneResolve = null, waitLastCompileDone = new Promise((resolve)=>{
-        waitLastCompileDoneResolve = resolve;
-    });
-    context.hooks.onAfterDevCompile.tap(({ stats })=>{
-        lastStats = 'stats' in stats ? stats.stats : [
-            stats
-        ], waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null);
-    });
-    let startCompile = async ()=>{
+    let compileState = (stats = Array(environmentCount = context.environmentList.length), waiters = Array.from({
+        length: environmentCount
+    }, createDeferred), {
+        reset (index) {
+            stats[index] && (stats[index] = void 0, waiters[index] = createDeferred());
+        },
+        done (index, nextStats) {
+            stats[index] = nextStats, waiters[index].resolve(nextStats);
+        },
+        async wait (index) {
+            let currentStats = stats[index];
+            return currentStats || waiters[index].promise;
+        }
+    }), startCompile = async ()=>{
         let compiler = await createCompiler();
         if (!compiler) throw Error(`${color.dim('[rsbuild:server]')} Failed to get compiler instance.`);
         context.publicPathnames = getPublicPathnames(compiler_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
             getPublicPathFromCompiler(compiler)
-        ], config.server.base), compiler?.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
-            lastStats && (waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null), waitLastCompileDone = new Promise((resolve)=>{
-                waitLastCompileDoneResolve = resolve;
-            }));
-        });
+        ], config.server.base);
+        let hookOptions = {
+            name: 'rsbuild:environment-api',
+            stage: -10000
+        };
+        compiler_isMultiCompiler(compiler) ? compiler.compilers.forEach((compiler, index)=>{
+            compiler.hooks.watchRun.tap(hookOptions, ()=>{
+                compileState.reset(index);
+            }), compiler.hooks.done.tap(hookOptions, (stats)=>{
+                compileState.done(index, stats);
+            });
+        }) : (compiler.hooks.watchRun.tap(hookOptions, ()=>{
+            compileState.reset(0);
+        }), compiler.hooks.done.tap(hookOptions, (stats)=>{
+            compileState.done(0, stats);
+        }));
         let buildManager = new BuildManager({
             context,
             config,
@@ -8152,18 +8182,18 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             },
             getStats: async ()=>{
                 if (!state.buildManager) throw Error(getErrorMsg('getStats'));
-                return await waitLastCompileDone, lastStats[index];
+                return compileState.wait(index);
             },
             loadBundle: async (entryName)=>{
                 if (!state.buildManager) throw Error(getErrorMsg('loadBundle'));
-                return await waitLastCompileDone, cacheableLoadBundle(lastStats[index], entryName, {
+                return cacheableLoadBundle(await compileState.wait(index), entryName, {
                     readFileSync: state.buildManager.readFileSync,
                     environment
                 });
             },
             getTransformedHtml: async (entryName)=>{
                 if (!state.buildManager) throw Error(getErrorMsg('getTransformedHtml'));
-                return await waitLastCompileDone, cacheableTransformedHtml(lastStats[index], entryName, {
+                return cacheableTransformedHtml(await compileState.wait(index), entryName, {
                     readFileSync: state.buildManager.readFileSync,
                     environment
                 });
@@ -9454,7 +9484,7 @@ try {
                                 for (let file of chunkFiles){
                                     file.isInitial || (isCSSPath(file.path) ? asyncCSS.push(file.path) : asyncJS.push(file.path));
                                     let relatedLICENSE = licenseMap.get(file.path);
-                                    if (relatedLICENSE && assets.add(relatedLICENSE), file.chunk) for (let auxiliaryFile of file.chunk.auxiliaryFiles)assets.add(auxiliaryFile);
+                                    if (relatedLICENSE && assets.add(relatedLICENSE), file.chunk) for (let auxiliaryFile of file.chunk.auxiliaryFiles)assets.add(manifestOptions.prefix ? ensureAssetPrefix(auxiliaryFile, publicPath) : auxiliaryFile);
                                 }
                                 let entryManifest = {};
                                 assets.size && (entryManifest.assets = Array.from(assets));
@@ -9519,18 +9549,39 @@ try {
             name: 'rsbuild:lazy-compilation',
             apply: 'serve',
             setup (api) {
-                api.modifyBundlerChain((chain, { environment, target })=>{
+                api.modifyBundlerChain(async (chain, { environment, target })=>{
                     if ('web' !== target) return;
-                    let { config } = environment, options = config.dev?.lazyCompilation;
+                    let { config } = environment;
+                    if (!config.dev.hmr && !config.dev.liveReload) return;
+                    let options = config.dev?.lazyCompilation;
                     if (options) {
-                        if (!0 === options && Object.keys(chain.entryPoints.entries() || {}).length <= 1) return void chain.lazyCompilation({
-                            entries: !1,
-                            imports: !0
-                        });
+                        if (!0 === options) {
+                            let entries = chain.entryPoints.entries() || {}, serverUrl = await getServerUrlFromClientConfig(config, api.context);
+                            if (Object.keys(entries).length <= 1) return void chain.lazyCompilation({
+                                entries: !1,
+                                imports: !0,
+                                ...serverUrl ? {
+                                    serverUrl
+                                } : {}
+                            });
+                            if (serverUrl) return void chain.lazyCompilation({
+                                entries: !0,
+                                imports: !0,
+                                serverUrl
+                            });
+                        }
                         if ('object' == typeof options && 'string' == typeof options.serverUrl && api.context.devServer) return void chain.lazyCompilation({
                             ...options,
                             serverUrl: replacePortPlaceholder(options.serverUrl, api.context.devServer.port)
                         });
+                        if ('object' == typeof options) {
+                            let serverUrl = await getServerUrlFromClientConfig(config, api.context);
+                            chain.lazyCompilation(serverUrl ? {
+                                ...options,
+                                serverUrl
+                            } : options);
+                            return;
+                        }
                         chain.lazyCompilation(options);
                     }
                 });
@@ -9941,7 +9992,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.12"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.14"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -10012,7 +10063,7 @@ function initNodeEnv(command) {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.12\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.14\n`);
 }
 function setupLogLevel() {
     if (cli_argv.length <= 3) return;
@@ -10034,5 +10085,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.12";
+let src_version = "2.0.14";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };

package/dist-types/server/compileState.d.ts

@@ -0,0 +1,5 @@
+export declare const createCompileState: (environmentCount: number) => {
+    reset(index: number): void;
+    done(index: number, nextStats: Rspack.Stats): void;
+    wait(index: number): Promise<Rspack.Stats>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {

package/types.d.ts

@@ -11,7 +11,7 @@
  * }
  * ```
  */
-// rslint-disable-next-line @typescript-eslint/no-empty-interface
+// rslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface RsbuildTypeOptions {}
 
 /**