@rsbuild/core 0.2.11 → 0.2.13

package/dist/cli/commands.d.ts

@@ -1,7 +1,7 @@
 import type { RsbuildMode } from '..';
 export type CommonOptions = {
     config?: string;
-    open?: boolean;
+    open?: boolean | string;
     host?: string;
     port?: number;
 };

package/dist/cli/commands.js

@@ -34,7 +34,7 @@ __export(commands_exports, {
 module.exports = __toCommonJS(commands_exports);
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
-var import_commander = require("../../compiled/commander");
+var import_commander = require("@rsbuild/shared/commander");
 var import_loadEnv = require("../loadEnv");
 var import_config = require("./config");
 let commonOpts = {};
@@ -60,7 +60,7 @@ async function init({
     };
     if (commonOpts.open && !config.dev?.startUrl) {
       config.dev || (config.dev = {});
-      config.dev.startUrl = true;
+      config.dev.startUrl = commonOpts.open;
     }
     if (commonOpts.host) {
       config.server || (config.server = {});
@@ -83,8 +83,8 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.11");
-  import_commander.program.command("dev").option("--open", "open the page in browser on startup").option(
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.13");
+  import_commander.program.command("dev").option("--open [url]", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"
   ).option(
@@ -118,7 +118,7 @@ function runCli() {
       process.exit(1);
     }
   });
-  import_commander.program.command("preview").option("--open", "open the page in browser on startup").option(
+  import_commander.program.command("preview").option("--open [url]", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"
   ).option(

package/dist/cli/prepare.js

@@ -34,7 +34,7 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.11"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.13"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/client/hmr.js

@@ -394,7 +394,6 @@ function getSocketUrl(urlParts, location) {
     });
 }
 // src/client/hmr/index.ts
-var hadRuntimeError = false;
 var socketUrl = createSocketUrl(__resourceQuery);
 var isFirstCompilation = true;
 var mostRecentCompilationHash = null;
@@ -489,7 +488,7 @@ function tryApplyUpdates() {
         return;
     }
     function handleApplyUpdates(err, updatedModules) {
-        var wantsForcedReload = err || !updatedModules || hadRuntimeError;
+        var wantsForcedReload = err || !updatedModules;
         if (wantsForcedReload) {
             window.location.reload();
             return;

package/dist/index.d.ts

@@ -8,4 +8,4 @@ export { loadConfig, defineConfig } from './cli/config';
 export { logger, mergeRsbuildConfig } from '@rsbuild/shared';
 export type { Rspack } from './provider';
 export type { RsbuildConfig, NormalizedConfig, RsbuildPlugin, RsbuildPluginAPI, } from './types';
-export type { Context as RsbuildContext, RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';
+export type { RsbuildMode, RsbuildEntry, RsbuildTarget, RsbuildContext, RsbuildInstance, CreateRsbuildOptions, InspectConfigOptions, OnExitFn, OnAfterBuildFn, OnAfterCreateCompilerFn, OnAfterStartDevServerFn, OnAfterStartProdServerFn, OnBeforeBuildFn, OnBeforeStartDevServerFn, OnBeforeStartProdServerFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, } from '@rsbuild/shared';

package/dist/plugins/bundleAnalyzer.js

@@ -31,13 +31,23 @@ __export(bundleAnalyzer_exports, {
   pluginBundleAnalyzer: () => pluginBundleAnalyzer
 });
 module.exports = __toCommonJS(bundleAnalyzer_exports);
+var import_shared = require("@rsbuild/shared");
+const isUseAnalyzer = (config) => process.env.BUNDLE_ANALYZE || config.performance?.bundleAnalyze;
 function pluginBundleAnalyzer() {
   return {
     name: "rsbuild:bundle-analyzer",
     setup(api) {
+      api.modifyRsbuildConfig((config) => {
+        if ((0, import_shared.isProd)() || !isUseAnalyzer(config)) {
+          return;
+        }
+        config.dev || (config.dev = {});
+        config.dev.writeToDisk = true;
+        return config;
+      });
       api.modifyBundlerChain(async (chain, { CHAIN_ID, target }) => {
         const config = api.getNormalizedConfig();
-        if (!process.env.BUNDLE_ANALYZE && !config.performance.bundleAnalyze) {
+        if (!isUseAnalyzer(config)) {
           return;
         }
         const { default: BundleAnalyzer } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/webpack-bundle-analyzer")));

package/dist/plugins/entry.js

@@ -31,12 +31,39 @@ const pluginEntry = () => ({
       const { preEntry } = config.source;
       const injectCoreJsEntry = config.output.polyfill === "entry" && !isServer && !isServiceWorker;
       Object.keys(entry).forEach((entryName) => {
-        const appendEntry = (file) => chain.entry(entryName).add(file);
+        const entryImport = [];
+        let entryDescription = null;
+        const appendEntry = (item) => {
+          if (typeof item === "string") {
+            entryImport.push(item);
+            return;
+          }
+          if (item.import) {
+            entryImport.push(...(0, import_shared.castArray)(item.import));
+          }
+          if (entryDescription) {
+            Object.assign(entryDescription, item);
+          } else {
+            entryDescription = item;
+          }
+        };
         preEntry.forEach(appendEntry);
         if (injectCoreJsEntry) {
           appendEntry((0, import_shared.createVirtualModule)('import "core-js";'));
         }
         (0, import_shared.castArray)(entry[entryName]).forEach(appendEntry);
+        chain.entryPoints.set(entryName, {
+          // @ts-expect-error EntryDescription type mismatch
+          values() {
+            if (entryDescription) {
+              return {
+                ...entryDescription,
+                import: entryImport
+              };
+            }
+            return entryImport;
+          }
+        });
       });
     });
     api.onBeforeCreateCompiler(({ bundlerConfigs }) => {

package/dist/plugins/html.js

@@ -136,11 +136,13 @@ function getTemplateParameters(entryName, config, assetPrefix) {
   };
 }
 function getChunks(entryName, entryValue) {
-  const dependOn = [];
   if ((0, import_shared.isPlainObject)(entryValue)) {
-    dependOn.push(...entryValue.dependOn);
+    const { dependOn } = entryValue;
+    if (Array.isArray(dependOn)) {
+      return [...dependOn, entryName];
+    }
   }
-  return [...dependOn, entryName];
+  return [entryName];
 }
 const applyInjectTags = (api) => {
   api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
@@ -194,7 +196,11 @@ const pluginHtml = () => ({
         await Promise.all(
           entryNames.map(async (entryName) => {
             const entryValue = entries[entryName].values();
-            const chunks = getChunks(entryName, entryValue);
+            const chunks = getChunks(
+              entryName,
+              // @ts-expect-error EntryDescription type mismatch
+              entryValue
+            );
             const inject = getInject(entryName, config);
             const filename = htmlPaths[entryName];
             const { templatePath, templateContent } = await getTemplate(

package/dist/plugins/index.js

@@ -53,7 +53,8 @@ const plugins = {
   networkPerformance: () => Promise.resolve().then(() => __toESM(require("./networkPerformance"))).then((m) => m.pluginNetworkPerformance()),
   preloadOrPrefetch: () => Promise.resolve().then(() => __toESM(require("./preloadOrPrefetch"))).then((m) => m.pluginPreloadOrPrefetch()),
   performance: () => Promise.resolve().then(() => __toESM(require("./performance"))).then((m) => m.pluginPerformance()),
-  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine())
+  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine()),
+  server: () => Promise.resolve().then(() => __toESM(require("./server"))).then((m) => m.pluginServer())
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/{provider/plugins → plugins}/server.d.ts

@@ -1,2 +1,2 @@
-import type { RsbuildPlugin } from '../../types';
+import type { RsbuildPlugin } from '../types';
 export declare const pluginServer: () => RsbuildPlugin;

package/dist/{provider/plugins → plugins}/server.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,49 +15,32 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
   pluginServer: () => pluginServer
 });
 module.exports = __toCommonJS(server_exports);
-var import_fs = __toESM(require("fs"));
+var import_shared = require("@rsbuild/shared");
 var import_path = require("path");
 const pluginServer = () => ({
   name: "rsbuild:server",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { isProd }) => {
+    api.onBeforeBuild(async () => {
       const config = api.getNormalizedConfig();
-      if (isProd && config.server?.publicDir) {
+      if (config.server?.publicDir) {
         const { name, copyOnBuild } = config.server?.publicDir;
         if (!copyOnBuild || !name) {
           return;
         }
         const publicDir = (0, import_path.isAbsolute)(name) ? name : (0, import_path.join)(api.context.rootPath, name);
-        const publicPattern = [
-          {
-            from: publicDir,
-            to: "",
-            noErrorOnMissing: true
-          }
-        ];
-        if (!import_fs.default.existsSync(publicDir)) {
+        if (!import_shared.fse.existsSync(publicDir)) {
           return;
         }
-        const { CopyRspackPlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
-        chain.plugin("public-dir").use(CopyRspackPlugin, [
-          {
-            patterns: publicPattern
-          }
-        ]);
+        await import_shared.fse.copy(publicDir, api.context.distPath, {
+          // dereference symlinks
+          dereference: true
+        });
       }
     });
   }

package/dist/plugins/splitChunks.d.ts

@@ -1,2 +1,4 @@
 import type { RsbuildPlugin } from '../types';
+export declare const MODULE_PATH_REGEX: RegExp;
+export declare function getPackageNameFromModulePath(modulePath: string): string | undefined;
 export declare function pluginSplitChunks(): RsbuildPlugin;

package/dist/plugins/splitChunks.js

@@ -28,6 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var splitChunks_exports = {};
 __export(splitChunks_exports, {
+  MODULE_PATH_REGEX: () => MODULE_PATH_REGEX,
+  getPackageNameFromModulePath: () => getPackageNameFromModulePath,
   pluginSplitChunks: () => pluginSplitChunks
 });
 module.exports = __toCommonJS(splitChunks_exports);
@@ -84,6 +86,16 @@ function splitByExperience(ctx) {
     }
   };
 }
+const MODULE_PATH_REGEX = /[\\/]node_modules[\\/](\.pnpm[\\/])?(?:(@[^[\\/]+)(?:[\\/]))?([^\\/]+)/;
+function getPackageNameFromModulePath(modulePath) {
+  const handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
+  if (!handleModuleContext) {
+    return void 0;
+  }
+  const [, , scope, name] = handleModuleContext;
+  const packageName = ["npm", (scope ?? "").replace("@", ""), name].filter(Boolean).join(".");
+  return packageName;
+}
 function splitByModule(ctx) {
   const { override, userDefinedCacheGroups, defaultConfig } = ctx;
   return {
@@ -99,7 +111,7 @@ function splitByModule(ctx) {
         priority: -10,
         test: import_shared.NODE_MODULES_REGEX,
         name(module2) {
-          return module2 ? (0, import_shared.getPackageNameFromModulePath)(module2.context) : void 0;
+          return module2 ? getPackageNameFromModulePath(module2.context) : void 0;
         }
       },
       ...override.cacheGroups
@@ -220,5 +232,7 @@ function pluginSplitChunks() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MODULE_PATH_REGEX,
+  getPackageNameFromModulePath,
   pluginSplitChunks
 });

package/dist/provider/core/createCompiler.d.ts

@@ -1,8 +1,8 @@
 import { type RspackConfig, type RspackCompiler, type RspackMultiCompiler, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
 import { type InitConfigsOptions } from './initConfigs';
-import type { Context } from '../../types';
+import type { InternalContext } from '../../types';
 export declare function createCompiler({ context, rspackConfigs, }: {
-    context: Context;
+    context: InternalContext;
     rspackConfigs: RspackConfig[];
 }): Promise<RspackCompiler | RspackMultiCompiler>;
 export declare function createDevMiddleware(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<CreateDevMiddlewareReturns>;

package/dist/provider/core/createContext.d.ts

@@ -1,13 +1,13 @@
-import { RsbuildConfig, type Context as BaseContext, type BundlerType, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import { RsbuildConfig, type BundlerType, type RsbuildContext, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { InternalContext } from '../../types';
 /**
  * Create context by config.
  */
-export declare function createContextByConfig(options: Required<CreateRsbuildOptions>, bundlerType: BundlerType, config?: RsbuildConfig): BaseContext;
-export declare function updateContextByNormalizedConfig(context: BaseContext, config: NormalizedConfig): void;
-export declare function createPublicContext(context: BaseContext): Readonly<BaseContext>;
+export declare function createContextByConfig(options: Required<CreateRsbuildOptions>, bundlerType: BundlerType, config?: RsbuildConfig): RsbuildContext;
+export declare function updateContextByNormalizedConfig(context: RsbuildContext, config: NormalizedConfig): void;
+export declare function createPublicContext(context: RsbuildContext): Readonly<RsbuildContext>;
 /**
  * Generate the actual context used in the build,
  * which can have a lot of overhead and take some side effects.
  */
-export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig, bundlerType: BundlerType): Promise<Context>;
+export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig, bundlerType: BundlerType): Promise<InternalContext>;

package/dist/provider/core/createContext.js

@@ -59,7 +59,7 @@ function createContextByConfig(options, bundlerType, config = {}) {
   const context = {
     entry: config.source?.entry || getDefaultEntry(rootPath),
     targets: config.output?.targets || [],
-    version: "0.2.11",
+    version: "0.2.13",
     rootPath,
     distPath,
     cachePath,

package/dist/provider/core/devMiddleware.d.ts

@@ -1,3 +1,3 @@
-import { DevMiddleware } from '@rsbuild/shared';
+import { type DevMiddleware } from '@rsbuild/shared';
 import type { Compiler, MultiCompiler } from '@rspack/core';
 export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => NonNullable<DevMiddleware>;

package/dist/provider/core/initConfigs.d.ts

@@ -1,7 +1,7 @@
 import { type PluginStore, type RspackConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context, NormalizedConfig } from '../../types';
+import type { InternalContext, NormalizedConfig } from '../../types';
 export type InitConfigsOptions = {
-    context: Context;
+    context: InternalContext;
     pluginStore: PluginStore;
     rsbuildOptions: Required<CreateRsbuildOptions>;
 };

package/dist/provider/core/initPlugins.d.ts

@@ -1,6 +1,7 @@
 import { type PluginStore, type RsbuildPluginAPI } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { InternalContext, NormalizedConfig } from '../../types';
+export declare function getHTMLPathByEntry(entryName: string, config: NormalizedConfig): string;
 export declare function getPluginAPI({ context, pluginStore, }: {
-    context: Context;
+    context: InternalContext;
     pluginStore: PluginStore;
 }): RsbuildPluginAPI;

package/dist/provider/core/initPlugins.js

@@ -18,11 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var initPlugins_exports = {};
 __export(initPlugins_exports, {
+  getHTMLPathByEntry: () => getHTMLPathByEntry,
   getPluginAPI: () => getPluginAPI
 });
 module.exports = __toCommonJS(initPlugins_exports);
 var import_shared = require("@rsbuild/shared");
 var import_createContext = require("./createContext");
+function getHTMLPathByEntry(entryName, config) {
+  const htmlPath = (0, import_shared.getDistPath)(config, "html");
+  const filename = config.html.outputStructure === "flat" ? `${entryName}.html` : `${entryName}/index.html`;
+  return (0, import_shared.removeLeadingSlash)(`${htmlPath}/${filename}`);
+}
 function getPluginAPI({
   context,
   pluginStore
@@ -51,7 +57,7 @@ function getPluginAPI({
   const getHTMLPaths = () => {
     return Object.keys(context.entry).reduce(
       (prev, key) => {
-        prev[key] = (0, import_shared.getHTMLPathByEntry)(key, getNormalizedConfig());
+        prev[key] = getHTMLPathByEntry(key, getNormalizedConfig());
         return prev;
       },
       {}
@@ -86,5 +92,6 @@ function getPluginAPI({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  getHTMLPathByEntry,
   getPluginAPI
 });

package/dist/provider/core/rspackConfig.d.ts

@@ -1,6 +1,6 @@
 import { type RspackConfig, type RsbuildTarget } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { InternalContext } from '../../types';
 export declare function generateRspackConfig({ target, context, }: {
     target: RsbuildTarget;
-    context: Context;
+    context: InternalContext;
 }): Promise<RspackConfig>;

package/dist/provider/index.d.ts

@@ -7,5 +7,5 @@ export { withDefaultConfig } from './config';
 export { initRsbuildConfig } from './core/initConfigs';
 export { getPluginAPI } from './core/initPlugins';
 export { applyBaseCSSRule, applyCSSModuleRule } from './plugins/css';
-export type { Context } from '../types';
+export type { InternalContext } from '../types';
 export { setHTMLPlugin, getHTMLPlugin } from './htmlPluginUtil';

package/dist/provider/plugins/css.d.ts

@@ -1,10 +1,10 @@
-import { type BundlerChain, type Context, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
+import { type BundlerChain, type RsbuildContext, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
 import type { RsbuildPlugin, NormalizedConfig } from '../../types';
 export declare const enableNativeCss: (config: NormalizedConfig) => boolean;
 export declare function applyBaseCSSRule({ rule, config, context, utils: { target, isProd, isServer, isWebWorker, CHAIN_ID }, importLoaders, }: {
     rule: ReturnType<BundlerChain['module']['rule']>;
     config: NormalizedConfig;
-    context: Context;
+    context: RsbuildContext;
     utils: ModifyBundlerChainUtils;
     importLoaders?: number;
 }): Promise<void>;

package/dist/provider/shared.js

@@ -73,7 +73,7 @@ const applyDefaultPlugins = (plugins) => (0, import_shared3.awaitableGetter)([
   plugins.networkPerformance(),
   plugins.preloadOrPrefetch(),
   plugins.performance(),
-  Promise.resolve().then(() => __toESM(require("./plugins/server"))).then((m) => m.pluginServer()),
+  plugins.server(),
   Promise.resolve().then(() => __toESM(require("./plugins/rspackProfile"))).then((m) => m.pluginRspackProfile())
 ]);
 const rspackMinVersion = "0.4.0";

package/dist/rspack/HtmlAppIconPlugin.js

@@ -71,7 +71,7 @@ class HtmlAppIconPlugin {
         compilation.hooks.processAssets.tap(
           {
             name: this.name,
-            stage: import_shared.COMPILATION_PROCESS_STAGE.PROCESS_ASSETS_STAGE_PRE_PROCESS
+            stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS
           },
           (assets) => {
             const source = import_fs.default.readFileSync(this.iconPath);

package/dist/rspack/InlineChunkHtmlPlugin.js

@@ -163,7 +163,7 @@ class InlineChunkHtmlPlugin {
            * Remove marked inline assets in summarize stage,
            * which should be later than the emitting of html-webpack-plugin
            */
-          stage: import_shared.COMPILATION_PROCESS_STAGE.PROCESS_ASSETS_STAGE_SUMMARIZE
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
         },
         () => {
           const { devtool } = compiler.options;

package/dist/rspack/RemoveCssSourcemapPlugin.js

@@ -21,7 +21,6 @@ __export(RemoveCssSourcemapPlugin_exports, {
   RemoveCssSourcemapPlugin: () => RemoveCssSourcemapPlugin
 });
 module.exports = __toCommonJS(RemoveCssSourcemapPlugin_exports);
-var import_shared = require("@rsbuild/shared");
 class RemoveCssSourcemapPlugin {
   constructor() {
     this.name = "RemoveCssSourcemapPlugin";
@@ -31,7 +30,7 @@ class RemoveCssSourcemapPlugin {
       compilation.hooks.processAssets.tap(
         {
           name: this.name,
-          stage: import_shared.COMPILATION_PROCESS_STAGE.PROCESS_ASSETS_STAGE_SUMMARIZE
+          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
         },
         () => {
           Object.keys(compilation.assets).forEach((name) => {

package/dist/rspack/preload/HtmlPreloadOrPrefetchPlugin.js

@@ -58,11 +58,10 @@ function generateLinks(options, type, compilation, htmlPluginData, HTMLCount) {
   });
   const htmlChunks = (
     // Handle all chunks.
-    options.type === "all-assets" || HTMLCount === 1 ? extractedChunks : extractedChunks.filter(
-      (chunk) => (
-        // TODO: Not yet supported in rspack, maybe we should implement it in another way
-        // https://github.com/web-infra-dev/rspack/issues/3896
-        (0, import_helpers.doesChunkBelongToHtml)({
+    options.type === "all-assets" || HTMLCount === 1 ? extractedChunks : (
+      // Only handle chunks imported by this HtmlWebpackPlugin.
+      extractedChunks.filter(
+        (chunk) => (0, import_helpers.doesChunkBelongToHtml)({
           chunk,
           compilation,
           htmlPluginData,

package/dist/server/devServer.d.ts

@@ -1,12 +1,12 @@
-import { CreateDevMiddlewareReturns, StartDevServerOptions, StartServerResult, DevServerAPIs } from '@rsbuild/shared';
-import type { Context } from '../types';
+import { StartServerResult, type DevServerAPIs, type StartDevServerOptions, type CreateDevMiddlewareReturns } from '@rsbuild/shared';
+import type { InternalContext } from '../types';
 export declare function getServerAPIs<Options extends {
-    context: Context;
+    context: InternalContext;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler: customCompiler, getPortSilently, }?: StartDevServerOptions & {
     defaultPort?: number;
 }): Promise<DevServerAPIs>;
 export declare function startDevServer<Options extends {
-    context: Context;
+    context: InternalContext;
 }>(options: Options, createDevMiddleware: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevMiddlewareReturns>, { compiler, printURLs, logger: customLogger, getPortSilently, }?: StartDevServerOptions & {
     defaultPort?: number;
 }): Promise<StartServerResult>;

package/dist/server/devServer.js

@@ -33,6 +33,7 @@ __export(devServer_exports, {
 });
 module.exports = __toCommonJS(devServer_exports);
 var import_shared = require("@rsbuild/shared");
+var import_helper = require("./helper");
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_restart = require("./restart");
 var import_httpServer = require("./httpServer");
@@ -46,11 +47,11 @@ async function getServerAPIs(options, createDevMiddleware, {
     process.env.NODE_ENV = "development";
   }
   const rsbuildConfig = options.context.config;
-  const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
+  const { devServerConfig, port, host, https } = await (0, import_helper.getDevOptions)({
     rsbuildConfig,
     getPortSilently
   });
-  const defaultRoutes = (0, import_shared.formatRoutes)(
+  const defaultRoutes = (0, import_helper.formatRoutes)(
     options.context.entry,
     rsbuildConfig.output?.distPath?.html,
     rsbuildConfig.html?.outputStructure
@@ -141,7 +142,7 @@ async function startDevServer(options, createDevMiddleware, {
         throw new Error("Please return an array in the `printURLs` function.");
       }
     }
-    (0, import_shared.printServerURLs)(urls, defaultRoutes, logger);
+    (0, import_helper.printServerURLs)(urls, defaultRoutes, logger);
   }
   const compileMiddlewareAPI = await serverAPIs.startCompile();
   const devMiddlewares = await serverAPIs.getMiddlewares({

package/dist/server/helper.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import type { Logger, Routes, DevConfig, RsbuildEntry, RsbuildConfig, OutputStructure } from '@rsbuild/shared';
+export declare const formatRoutes: (entry: RsbuildEntry, prefix: string | undefined, outputStructure: OutputStructure | undefined) => Routes;
+export declare function printServerURLs(urls: Array<{
+    url: string;
+    label: string;
+}>, routes: Routes, logger?: Logger): void;
+/**
+ * hmr socket connect path
+ */
+export declare const HMR_SOCK_PATH = "/rsbuild-hmr";
+export declare const mergeDevOptions: ({ rsbuildConfig, port, }: {
+    rsbuildConfig: RsbuildConfig;
+    port: number;
+}) => DevConfig;
+export declare const getServerOptions: ({ rsbuildConfig, getPortSilently, }: {
+    rsbuildConfig: RsbuildConfig;
+    getPortSilently?: boolean | undefined;
+}) => Promise<{
+    port: number;
+    host: string;
+    https: boolean;
+    serverConfig: import("@rsbuild/shared").ServerConfig;
+}>;
+export declare const getDevOptions: ({ rsbuildConfig, getPortSilently, }: {
+    rsbuildConfig: RsbuildConfig;
+    getPortSilently?: boolean | undefined;
+}) => Promise<{
+    devServerConfig: {
+        hmr?: boolean | undefined;
+        liveReload?: boolean | undefined;
+        startUrl?: string | boolean | string[] | undefined;
+        beforeStartUrl?: import("@rsbuild/shared").ArrayOrNot<() => void | Promise<void>> | undefined;
+        assetPrefix?: string | boolean | undefined;
+        progressBar?: boolean | import("@rsbuild/shared").ProgressBarConfig | undefined;
+        client?: {
+            path?: string | undefined;
+            port?: string | undefined;
+            host?: string | undefined;
+            protocol?: string | undefined;
+        } | undefined;
+        setupMiddlewares?: ((middlewares: {
+            unshift: (...handlers: import("@rsbuild/shared").RequestHandler[]) => void;
+            push: (...handlers: import("@rsbuild/shared").RequestHandler[]) => void;
+        }, server: import("@rsbuild/shared").ServerAPIs) => void)[] | undefined;
+        writeToDisk?: boolean | ((filename: string) => boolean) | undefined;
+        compress?: boolean | undefined;
+        publicDir?: import("@rsbuild/shared").PublicDir | undefined;
+        port?: number | undefined;
+        https?: import("https").ServerOptions | undefined;
+        host?: string | undefined;
+        headers?: Record<string, string | string[]> | undefined;
+        htmlFallback?: import("@rsbuild/shared").HtmlFallback | undefined;
+        historyApiFallback?: boolean | import("@rsbuild/shared").HistoryApiFallbackOptions | undefined;
+        proxy?: import("@rsbuild/shared").ProxyOptions | undefined;
+        strictPort?: boolean | undefined;
+    };
+    port: number;
+    host: string;
+    https: boolean;
+}>;