@rsbuild/core 0.1.9 → 0.2.0

package/dist/cli/commands.js

@@ -47,8 +47,11 @@ async function init({
   }
   try {
     const root = process.cwd();
-    const { publicVars } = await (0, import_loadEnv.loadEnv)({ dir: root });
-    const config = await (0, import_config.loadConfig)(root, commonOpts.config);
+    const { publicVars } = await (0, import_loadEnv.loadEnv)({ cwd: root });
+    const config = await (0, import_config.loadConfig)({
+      cwd: root,
+      path: commonOpts.config
+    });
     const { createRsbuild } = await Promise.resolve().then(() => __toESM(require("../createRsbuild")));
     config.source || (config.source = {});
     config.source.define = {
@@ -81,7 +84,7 @@ async function init({
   }
 }
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.1.9");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.2.0");
   import_commander.program.command("dev").option("--open", "open the page in browser on startup").option(
     "--port <port>",
     "specify a port number for Rsbuild Server to listen"

package/dist/cli/config.d.ts

@@ -17,4 +17,10 @@ export type RsbuildConfigExport = RsbuildConfig | RsbuildConfigFn;
  */
 export declare function defineConfig(config: RsbuildConfig): RsbuildConfig;
 export declare function defineConfig(config: RsbuildConfigFn): RsbuildConfigFn;
-export declare function loadConfig(root: string, customConfig?: string): Promise<RsbuildConfig>;
+export declare function loadConfig({
+  cwd,
+  path
+}: {
+  cwd: string;
+  path?: string;
+}): Promise<RsbuildConfig>;

package/dist/cli/config.js

@@ -86,8 +86,11 @@ async function watchConfig(root, configFile) {
   watcher.on("change", callback);
   watcher.on("unlink", callback);
 }
-async function loadConfig(root, customConfig) {
-  const configFile = resolveConfigPath(root, customConfig);
+async function loadConfig({
+  cwd,
+  path
+}) {
+  const configFile = resolveConfigPath(cwd, path);
   if (!configFile) {
     return {};
   }
@@ -101,7 +104,7 @@ async function loadConfig(root, customConfig) {
     });
     const command = process.argv[2];
     if (command === "dev") {
-      watchConfig(root, configFile);
+      watchConfig(cwd, configFile);
     }
     const configExport = loadConfig2(configFile);
     if (typeof configExport === "function") {

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.1.9"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.2.0"}`}
 `);
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/createRsbuild.js

@@ -44,7 +44,6 @@ async function createRsbuild(options) {
   const provider = options.provider ? options.provider({ rsbuildConfig }) : await getRspackProvider(rsbuildConfig);
   const rsbuildOptions = {
     cwd: process.cwd(),
-    target: ["web"],
     ...options
   };
   const pluginStore = (0, import_shared.createPluginStore)();
@@ -56,6 +55,7 @@ async function createRsbuild(options) {
     initConfigs,
     inspectConfig,
     createCompiler,
+    createDevServer,
     startDevServer,
     applyDefaultPlugins
   } = await provider({
@@ -88,6 +88,7 @@ async function createRsbuild(options) {
     createCompiler,
     initConfigs,
     inspectConfig,
+    createDevServer,
     startDevServer,
     context: publicContext
   };

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  * the public API of @rsbuild/core.
  */
 export { createRsbuild } from './createRsbuild';
-export { defineConfig } from './cli/config';
+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';

package/dist/index.js

@@ -20,6 +20,7 @@ var src_exports = {};
 __export(src_exports, {
   createRsbuild: () => import_createRsbuild.createRsbuild,
   defineConfig: () => import_config.defineConfig,
+  loadConfig: () => import_config.loadConfig,
   logger: () => import_shared.logger,
   mergeRsbuildConfig: () => import_shared.mergeRsbuildConfig
 });
@@ -31,6 +32,7 @@ var import_shared = require("@rsbuild/shared");
 0 && (module.exports = {
   createRsbuild,
   defineConfig,
+  loadConfig,
   logger,
   mergeRsbuildConfig
 });

package/dist/loadEnv.d.ts

@@ -1,9 +1,9 @@
 export declare const getEnvFiles: () => string[];
 export declare function loadEnv({
-  dir,
+  cwd,
   prefixes
 }?: {
-  dir?: string;
+  cwd?: string;
   prefixes?: string[];
 }): Promise<{
   parsed: Record<string, string>;

package/dist/loadEnv.js

@@ -40,12 +40,12 @@ const getEnvFiles = () => {
   return [".env", ".env.local", `.env.${NODE_ENV}`, `.env.${NODE_ENV}.local`];
 };
 async function loadEnv({
-  dir = process.cwd(),
+  cwd = process.cwd(),
   prefixes = ["PUBLIC_"]
 } = {}) {
   const { parse } = await Promise.resolve().then(() => __toESM(require("../compiled/dotenv")));
   const { expand } = await Promise.resolve().then(() => __toESM(require("../compiled/dotenv-expand")));
-  const envPaths = getEnvFiles().map((filename) => (0, import_path.join)(dir, filename)).filter(import_shared.isFileSync);
+  const envPaths = getEnvFiles().map((filename) => (0, import_path.join)(cwd, filename)).filter(import_shared.isFileSync);
   const parsed = {};
   envPaths.forEach((envPath) => {
     Object.assign(parsed, parse(import_fs.default.readFileSync(envPath)));

package/dist/plugins/asset.js

@@ -48,8 +48,8 @@ const pluginAsset = () => ({
       const config = api.getNormalizedConfig();
       const createAssetRule = (assetType, exts) => {
         const regExp = getRegExpForExts(exts);
-        const distDir = (0, import_shared.getDistPath)(config.output, assetType);
-        const filename = (0, import_shared.getFilename)(config.output, assetType, isProd);
+        const distDir = (0, import_shared.getDistPath)(config, assetType);
+        const filename = (0, import_shared.getFilename)(config, assetType, isProd);
         const maxSize = config.output.dataUriLimit[assetType];
         const rule = chain.module.rule(assetType).test(regExp);
         (0, import_shared.chainStaticAssetRule)({

package/dist/plugins/basic.d.ts

@@ -0,0 +1,5 @@
+import type { RsbuildPlugin } from '../types';
+/**
+ * Provide some basic configs of rspack
+ */
+export declare const pluginBasic: () => RsbuildPlugin;

package/dist/plugins/basic.js

@@ -0,0 +1,68 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 basic_exports = {};
+__export(basic_exports, {
+  pluginBasic: () => pluginBasic
+});
+module.exports = __toCommonJS(basic_exports);
+var import_path = __toESM(require("path"));
+var import_shared = require("@rsbuild/shared");
+const pluginBasic = () => ({
+  name: "rsbuild:basic",
+  setup(api) {
+    api.modifyBundlerChain((chain, { env, isProd, target }) => {
+      const config = api.getNormalizedConfig();
+      chain.name(import_shared.TARGET_ID_MAP[target]);
+      chain.devtool((0, import_shared.getJsSourceMap)(config));
+      chain.context(api.context.rootPath);
+      chain.mode(isProd ? "production" : "development");
+      chain.merge({
+        infrastructureLogging: {
+          // Using `error` level to avoid `cache.PackFileCacheStrategy` logs
+          level: "error"
+        }
+      });
+      chain.performance.hints(false);
+      chain.module.parser.merge({
+        javascript: {
+          exportsPresence: "error"
+        }
+      });
+      if (env === "development") {
+        chain.output.devtoolModuleFilenameTemplate(
+          (info) => import_path.default.resolve(info.absoluteResourcePath).replace(/\\/g, "/")
+        );
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginBasic
+});

package/dist/plugins/html.d.ts

@@ -1,4 +1,4 @@
-import type { HtmlConfig, RsbuildPluginAPI, NormalizedConfig, NormalizedOutputConfig } from '@rsbuild/shared';
+import type { HtmlConfig, RsbuildPluginAPI, NormalizedConfig } from '@rsbuild/shared';
 import type { RsbuildPlugin } from '../types';
 export declare function getTitle(entryName: string, config: NormalizedConfig): string;
 export declare function getInject(entryName: string, config: NormalizedConfig): import("@rsbuild/shared").ScriptInject;
@@ -11,7 +11,6 @@ export declare function getFavicon(entryName: string, config: {
 }): string;
 export declare function getMetaTags(entryName: string, config: {
   html: HtmlConfig;
-  output: NormalizedOutputConfig;
 }, templateContent?: string): import("@rsbuild/shared").MetaOptions;
 export declare const applyInjectTags: (api: RsbuildPluginAPI) => void;
 export declare const pluginHtml: () => RsbuildPlugin;

package/dist/plugins/html.js

@@ -142,7 +142,7 @@ function getChunks(entryName, entryValue) {
   return [...dependOn, entryName];
 }
 const applyInjectTags = (api) => {
-  api.modifyBundlerChain(async (chain, { HtmlPlugin, CHAIN_ID }) => {
+  api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
     const config = api.getNormalizedConfig();
     const tags = (0, import_shared.castArray)(config.html.tags).filter(Boolean);
     const tagsByEntries = config.html.tagsByEntries || {};
@@ -157,7 +157,6 @@ const applyInjectTags = (api) => {
     }
     const { HtmlTagsPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlTagsPlugin")));
     const sharedOptions = {
-      HtmlPlugin,
       append: true,
       hash: false,
       publicPath: true,
@@ -215,11 +214,12 @@ const pluginHtml = () => ({
               minify,
               filename,
               template: templatePath,
+              entryName,
               templateParameters,
               scriptLoading: config.html.scriptLoading
             };
             const htmlInfo = {};
-            htmlInfoMap[filename] = htmlInfo;
+            htmlInfoMap[entryName] = htmlInfo;
             if (templateContent) {
               htmlInfo.templateContent = templateContent;
             }
@@ -247,12 +247,12 @@ const pluginHtml = () => ({
           })
         );
         const { HtmlBasicPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlBasicPlugin")));
-        chain.plugin(CHAIN_ID.PLUGIN.HTML_BASIC).use(HtmlBasicPlugin, [{ HtmlPlugin, info: htmlInfoMap }]);
+        chain.plugin(CHAIN_ID.PLUGIN.HTML_BASIC).use(HtmlBasicPlugin, [{ info: htmlInfoMap }]);
         if (config.security) {
           const { nonce } = config.security;
           if (nonce) {
             const { HtmlNoncePlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlNoncePlugin")));
-            chain.plugin(CHAIN_ID.PLUGIN.HTML_NONCE).use(HtmlNoncePlugin, [{ nonce, HtmlPlugin }]);
+            chain.plugin(CHAIN_ID.PLUGIN.HTML_NONCE).use(HtmlNoncePlugin, [{ nonce }]);
           }
         }
         if (config.html) {
@@ -261,15 +261,15 @@ const pluginHtml = () => ({
             const { HtmlCrossOriginPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlCrossOriginPlugin")));
             const formattedCrossorigin = crossorigin === true ? "anonymous" : crossorigin;
             chain.plugin(CHAIN_ID.PLUGIN.HTML_CROSS_ORIGIN).use(HtmlCrossOriginPlugin, [
-              { crossOrigin: formattedCrossorigin, HtmlPlugin }
+              { crossOrigin: formattedCrossorigin }
             ]);
             chain.output.crossOriginLoading(formattedCrossorigin);
           }
           if (appIcon) {
             const { HtmlAppIconPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlAppIconPlugin")));
-            const distDir = (0, import_shared.getDistPath)(config.output, "image");
+            const distDir = (0, import_shared.getDistPath)(config, "image");
             const iconPath = import_path.default.isAbsolute(appIcon) ? appIcon : import_path.default.join(api.context.rootPath, appIcon);
-            chain.plugin(CHAIN_ID.PLUGIN.APP_ICON).use(HtmlAppIconPlugin, [{ iconPath, distDir, HtmlPlugin }]);
+            chain.plugin(CHAIN_ID.PLUGIN.APP_ICON).use(HtmlAppIconPlugin, [{ iconPath, distDir }]);
           }
         }
       }

package/dist/plugins/index.js

@@ -32,11 +32,11 @@ __export(plugins_exports, {
 });
 module.exports = __toCommonJS(plugins_exports);
 const plugins = {
+  basic: () => Promise.resolve().then(() => __toESM(require("./basic"))).then((m) => m.pluginBasic()),
   html: () => Promise.resolve().then(() => __toESM(require("./html"))).then((m) => m.pluginHtml()),
   cleanOutput: () => Promise.resolve().then(() => __toESM(require("./cleanOutput"))).then((m) => m.pluginCleanOutput()),
   startUrl: () => Promise.resolve().then(() => __toESM(require("./startUrl"))).then((m) => m.pluginStartUrl()),
   fileSize: () => Promise.resolve().then(() => __toESM(require("./fileSize"))).then((m) => m.pluginFileSize()),
-  devtool: () => Promise.resolve().then(() => __toESM(require("./devtool"))).then((m) => m.pluginDevtool()),
   target: () => Promise.resolve().then(() => __toESM(require("./target"))).then((m) => m.pluginTarget()),
   entry: () => Promise.resolve().then(() => __toESM(require("./entry"))).then((m) => m.pluginEntry()),
   cache: () => Promise.resolve().then(() => __toESM(require("./cache"))).then((m) => m.pluginCache()),
@@ -53,8 +53,7 @@ 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()),
-  server: () => Promise.resolve().then(() => __toESM(require("./server"))).then((m) => m.pluginServer())
+  define: () => Promise.resolve().then(() => __toESM(require("./define"))).then((m) => m.pluginDefine())
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/plugins/inlineChunk.js

@@ -35,35 +35,32 @@ var import_shared = require("@rsbuild/shared");
 const pluginInlineChunk = () => ({
   name: "rsbuild:inline-chunk",
   setup(api) {
-    api.modifyBundlerChain(
-      async (chain, { target, CHAIN_ID, isProd, HtmlPlugin }) => {
-        const config = api.getNormalizedConfig();
-        if ((0, import_shared.isHtmlDisabled)(config, target) || !isProd) {
-          return;
-        }
-        const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/InlineChunkHtmlPlugin")));
-        const { inlineStyles, inlineScripts } = config.output;
-        const scriptTests = [];
-        const styleTests = [];
-        if (inlineScripts) {
-          scriptTests.push(inlineScripts === true ? import_shared.JS_REGEX : inlineScripts);
-        }
-        if (inlineStyles) {
-          styleTests.push(inlineStyles === true ? import_shared.CSS_REGEX : inlineStyles);
-        }
-        if (!scriptTests.length && !styleTests.length) {
-          return;
-        }
-        chain.plugin(CHAIN_ID.PLUGIN.INLINE_HTML).use(InlineChunkHtmlPlugin, [
-          HtmlPlugin,
-          {
-            styleTests,
-            scriptTests,
-            distPath: (0, import_shared.pick)(config.output.distPath, ["js", "css"])
-          }
-        ]);
+    api.modifyBundlerChain(async (chain, { target, CHAIN_ID, isProd }) => {
+      const config = api.getNormalizedConfig();
+      if ((0, import_shared.isHtmlDisabled)(config, target) || !isProd) {
+        return;
       }
-    );
+      const { InlineChunkHtmlPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/InlineChunkHtmlPlugin")));
+      const { inlineStyles, inlineScripts } = config.output;
+      const scriptTests = [];
+      const styleTests = [];
+      if (inlineScripts) {
+        scriptTests.push(inlineScripts === true ? import_shared.JS_REGEX : inlineScripts);
+      }
+      if (inlineStyles) {
+        styleTests.push(inlineStyles === true ? import_shared.CSS_REGEX : inlineStyles);
+      }
+      if (!scriptTests.length && !styleTests.length) {
+        return;
+      }
+      chain.plugin(CHAIN_ID.PLUGIN.INLINE_HTML).use(InlineChunkHtmlPlugin, [
+        {
+          styleTests,
+          scriptTests,
+          distPath: (0, import_shared.pick)(config.output.distPath, ["js", "css"])
+        }
+      ]);
+    });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/plugins/networkPerformance.js

@@ -35,7 +35,7 @@ const pluginNetworkPerformance = () => ({
   name: `plugin-network-performance`,
   setup(api) {
     api.modifyBundlerChain(
-      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker, HtmlPlugin }) => {
+      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker }) => {
         const config = api.getNormalizedConfig();
         const {
           performance: { dnsPrefetch, preconnect }
@@ -45,18 +45,10 @@ const pluginNetworkPerformance = () => ({
         }
         const { HtmlNetworkPerformancePlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlNetworkPerformancePlugin")));
         if (dnsPrefetch) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_DNS_PREFETCH).use(HtmlNetworkPerformancePlugin, [
-            dnsPrefetch,
-            "dnsPrefetch",
-            HtmlPlugin
-          ]);
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_DNS_PREFETCH).use(HtmlNetworkPerformancePlugin, [dnsPrefetch, "dnsPrefetch"]);
         }
         if (preconnect) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRECONNECT).use(HtmlNetworkPerformancePlugin, [
-            preconnect,
-            "preconnect",
-            HtmlPlugin
-          ]);
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRECONNECT).use(HtmlNetworkPerformancePlugin, [preconnect, "preconnect"]);
         }
       }
     );

package/dist/plugins/nodeAddons.js

@@ -54,7 +54,7 @@ const pluginNodeAddons = () => ({
           };
           const { name: pkgName } = require(pkgJSON);
           const config = api.getNormalizedConfig();
-          const serverPath = (0, import_shared.getDistPath)(config.output, "server");
+          const serverPath = (0, import_shared.getDistPath)(config, "server");
           return `${serverPath}/${getFilename(resourcePath, pkgName)}`;
         };
         chain.module.rule(CHAIN_ID.RULE.NODE).test(/\.node$/).use(CHAIN_ID.USE.NODE).loader((0, import_shared.getSharedPkgCompiledPath)("node-loader")).options({

package/dist/plugins/preloadOrPrefetch.js

@@ -35,7 +35,7 @@ const pluginPreloadOrPrefetch = () => ({
   name: `plugin-preload-or-prefetch`,
   setup(api) {
     api.modifyBundlerChain(
-      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker, HtmlPlugin }) => {
+      async (chain, { CHAIN_ID, isServer, isWebWorker, isServiceWorker }) => {
         const config = api.getNormalizedConfig();
         const {
           performance: { preload, prefetch }
@@ -44,22 +44,16 @@ const pluginPreloadOrPrefetch = () => ({
           return;
         }
         const HTMLCount = chain.entryPoints.values().length;
-        const { HTMLPreloadOrPrefetchPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/HtmlPreloadOrPrefetchPlugin")));
+        const { HtmlPreloadOrPrefetchPlugin } = await Promise.resolve().then(() => __toESM(require("../rspack/preload/HtmlPreloadOrPrefetchPlugin")));
         if (prefetch) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HTMLPreloadOrPrefetchPlugin, [
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HtmlPreloadOrPrefetchPlugin, [
             prefetch,
             "prefetch",
-            HtmlPlugin,
             HTMLCount
           ]);
         }
         if (preload) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HTMLPreloadOrPrefetchPlugin, [
-            preload,
-            "preload",
-            HtmlPlugin,
-            HTMLCount
-          ]);
+          chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HtmlPreloadOrPrefetchPlugin, [preload, "preload", HTMLCount]);
         }
       }
     );

package/dist/plugins/wasm.js

@@ -28,7 +28,7 @@ const pluginWasm = () => ({
   setup(api) {
     api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
       const config = api.getNormalizedConfig();
-      const distPath = (0, import_shared.getDistPath)(config.output, "wasm");
+      const distPath = (0, import_shared.getDistPath)(config, "wasm");
       chain.experiments({
         ...chain.get("experiments"),
         asyncWebAssembly: true

package/dist/provider/core/createCompiler.js

@@ -53,16 +53,23 @@ async function createCompiler({
   }
   const compiler = rspackConfigs.length === 1 ? rspack(rspackConfigs[0]) : rspack(rspackConfigs);
   let isFirstCompile = true;
-  compiler.hooks.watchRun.tap("rsbuild:compiling", () => {
-    if (isFirstCompile) {
+  let isVersionLogged = false;
+  let isCompiling = false;
+  const logRspackVersion = () => {
+    if (!isVersionLogged) {
       import_shared.logger.start(`Use Rspack v${rspack.rspackVersion}`);
+      isVersionLogged = true;
+    }
+  };
+  compiler.hooks.watchRun.tap("rsbuild:compiling", () => {
+    logRspackVersion();
+    if (!isCompiling) {
+      import_shared.logger.start("Compiling...");
     }
-    import_shared.logger.start("Compiling...");
+    isCompiling = true;
   });
   if ((0, import_shared.isProd)()) {
-    compiler.hooks.run.tap("rsbuild:run", () => {
-      import_shared.logger.start(`Use Rspack v${rspack.rspackVersion}`);
-    });
+    compiler.hooks.run.tap("rsbuild:run", logRspackVersion);
   }
   compiler.hooks.done.tap("rsbuild:done", async (stats) => {
     const obj = stats.toJson({
@@ -72,7 +79,7 @@ async function createCompiler({
     const printTime = (c, index) => {
       if (c.time) {
         const time = (0, import_shared.prettyTime)(c.time / 1e3);
-        const target = Array.isArray(context.target) ? context.target[index] : context.target;
+        const target = context.targets[index];
         const name = import_shared.TARGET_ID_MAP[target || "web"];
         import_shared.logger.ready(`${name} compiled in ${time}`);
       }
@@ -98,6 +105,7 @@ async function createCompiler({
         isFirstCompile
       });
     }
+    isCompiling = false;
     isFirstCompile = false;
   });
   await context.hooks.onAfterCreateCompilerHook.call({ compiler });

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

@@ -1,13 +1,13 @@
-import { RsbuildConfig, type Context as BaseContext, type BundlerType, type SourceConfig, type OutputConfig, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
+import { RsbuildConfig, type Context as BaseContext, type BundlerType, type NormalizedConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
 import type { Context } from '../../types';
 /**
  * Create context by config.
  */
-export declare function createContextByConfig(options: Required<CreateRsbuildOptions>, bundlerType: BundlerType, sourceConfig?: SourceConfig, outputConfig?: OutputConfig): BaseContext;
+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>;
 /**
  * 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): Promise<Context>;
+export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig, bundlerType: BundlerType): Promise<Context>;

package/dist/provider/core/createContext.js

@@ -47,29 +47,19 @@ function getDefaultEntry(root) {
   }
   return {};
 }
-function getAbsoluteDistPath(cwd, outputConfig) {
-  const root = (0, import_shared.getDistPath)(outputConfig, "root");
+function getAbsoluteDistPath(cwd, config) {
+  const root = (0, import_shared.getDistPath)(config, "root");
   return (0, import_path.isAbsolute)(root) ? root : (0, import_path.join)(cwd, root);
 }
-function createContextByConfig(options, bundlerType, sourceConfig = {}, outputConfig = {}) {
-  const { cwd, target } = options;
+function createContextByConfig(options, bundlerType, config = {}) {
+  const { cwd } = options;
   const rootPath = cwd;
-  const distPath = getAbsoluteDistPath(cwd, outputConfig);
+  const distPath = getAbsoluteDistPath(cwd, config);
   const cachePath = (0, import_path.join)(rootPath, "node_modules", ".cache");
-  if (sourceConfig.entries) {
-    import_shared.logger.warn(
-      "[Rsbuild] `source.entries` option has been renamed to `source.entry`, please update the Rsbuild config."
-    );
-    import_shared.logger.warn(
-      "[Rsbuild] `source.entries` option will be removed in Rsbuild v0.2.0."
-    );
-  }
   const context = {
-    entry: sourceConfig.entry || // TODO: remove sourceConfig.entries in v0.2.0
-    // compat with previous config
-    sourceConfig.entries || getDefaultEntry(rootPath),
-    version: "0.1.9",
-    target,
+    entry: config.source?.entry || getDefaultEntry(rootPath),
+    targets: config.output?.targets || [],
+    version: "0.2.0",
     rootPath,
     distPath,
     cachePath,
@@ -78,7 +68,8 @@ function createContextByConfig(options, bundlerType, sourceConfig = {}, outputCo
   return context;
 }
 function updateContextByNormalizedConfig(context, config) {
-  context.distPath = getAbsoluteDistPath(context.rootPath, config.output);
+  context.targets = config.output.targets;
+  context.distPath = getAbsoluteDistPath(context.rootPath, config);
   if (config.source.entry) {
     context.entry = config.source.entry;
   }
@@ -86,7 +77,7 @@ function updateContextByNormalizedConfig(context, config) {
 function createPublicContext(context) {
   const exposedKeys = [
     "entry",
-    "target",
+    "targets",
     "version",
     "rootPath",
     "distPath",
@@ -111,14 +102,9 @@ function createPublicContext(context) {
     }
   });
 }
-async function createContext(options, userRsbuildConfig) {
+async function createContext(options, userRsbuildConfig, bundlerType) {
   const rsbuildConfig = (0, import_config.withDefaultConfig)(userRsbuildConfig);
-  const context = createContextByConfig(
-    options,
-    "rspack",
-    rsbuildConfig.source,
-    rsbuildConfig.output
-  );
+  const context = createContextByConfig(options, bundlerType, rsbuildConfig);
   const tsconfigPath = (0, import_path.join)(context.rootPath, import_shared.TS_CONFIG_FILE);
   return {
     ...context,

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

@@ -1,5 +1,5 @@
 import { type PluginStore, type RspackConfig, type CreateRsbuildOptions } from '@rsbuild/shared';
-import type { Context } from '../../types';
+import type { Context, NormalizedConfig } from '../../types';
 export type InitConfigsOptions = {
   context: Context;
   pluginStore: PluginStore;
@@ -8,7 +8,7 @@ export type InitConfigsOptions = {
 export declare function initRsbuildConfig({
   context,
   pluginStore
-}: Pick<InitConfigsOptions, 'context' | 'pluginStore'>): Promise<void>;
+}: Pick<InitConfigsOptions, 'context' | 'pluginStore'>): Promise<NormalizedConfig>;
 export declare function initConfigs({
   context,
   pluginStore,