@rsbuild/core 0.0.16 → 0.0.18

package/dist/cli/commands.d.ts

@@ -4,4 +4,7 @@ export type InspectOptions = {
   output: string;
   verbose?: boolean;
 };
+export type DevOptions = {
+  open?: boolean;
+};
 export declare function setupProgram(rsbuild: RsbuildInstance): void;

package/dist/cli/commands.js

@@ -28,8 +28,10 @@ function setupProgram(rsbuild) {
   const pkgJson = (0, import_path.join)(__dirname, "../../package.json");
   const { version } = import_fs_extra.fs.readJSONSync(pkgJson);
   import_commander.program.name("rsbuild").usage("<command> [options]").version(version);
-  import_commander.program.command("dev").description("starting the dev server").action(async () => {
-    await rsbuild.startDevServer();
+  import_commander.program.command("dev").option(`--open`, "open the page in browser on startup").description("starting the dev server").action(async (options) => {
+    await rsbuild.startDevServer({
+      open: options.open
+    });
   });
   import_commander.program.command("build").description("build the app for production").action(async () => {
     await rsbuild.build();

package/dist/cli/config.d.ts

@@ -4,6 +4,10 @@ export type RsbuildConfig = BaseRsbuildConfig & {
     entries?: RsbuildEntry;
   };
   plugins?: RsbuildPlugin[];
+  /**
+   * @private only for testing
+   */
+  provider?: any;
 };
 export declare const defineConfig: (config: RsbuildConfig) => RsbuildConfig;
 export declare function loadConfig(): Promise<ReturnType<typeof defineConfig>>;

package/dist/cli/index.js

@@ -31,7 +31,8 @@ async function runCli(options = {}) {
   const config = await (0, import_config.loadConfig)();
   const rsbuild = await (0, import__.createRsbuild)({
     rsbuildConfig: config,
-    entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)()
+    entry: ((_a = config.source) == null ? void 0 : _a.entries) || (0, import_config.getDefaultEntries)(),
+    provider: config.provider
   });
   if (options.defaultPlugins) {
     rsbuild.addPlugins(options.defaultPlugins);

package/dist/plugins/define.js

@@ -21,36 +21,24 @@ __export(define_exports, {
   pluginDefine: () => pluginDefine
 });
 module.exports = __toCommonJS(define_exports);
-var import_lodash = require("lodash");
 var import_shared = require("@rsbuild/shared");
 const pluginDefine = () => ({
   name: "plugin-define",
-  async setup(api) {
-    api.modifyBundlerChain(
-      async (chain, { env, target, CHAIN_ID, bundler }) => {
-        const config = api.getNormalizedConfig();
-        const publicPath = chain.output.get("publicPath");
-        const assetPrefix = publicPath && typeof publicPath === "string" ? publicPath : config.output.assetPrefix;
-        const builtinVars = {
-          "process.env.NODE_ENV": process.env.NODE_ENV,
-          "process.env.ASSET_PREFIX": (0, import_shared.removeTailSlash)(assetPrefix)
-        };
-        const globalVars = (0, import_shared.mergeChainedOptions)({
-          defaults: builtinVars,
-          options: config.source.globalVars,
-          utils: { env, target }
-        });
-        const serializedVars = (0, import_lodash.mapValues)(
-          globalVars,
-          (value) => {
-            var _a;
-            return (_a = JSON.stringify(value)) != null ? _a : "undefined";
-          }
-        );
-        const defineExprs = config.source.define;
-        chain.plugin(CHAIN_ID.PLUGIN.DEFINE).use(bundler.DefinePlugin, [{ ...serializedVars, ...defineExprs }]);
-      }
-    );
+  setup(api) {
+    api.modifyBundlerChain((chain, { CHAIN_ID, bundler }) => {
+      const config = api.getNormalizedConfig();
+      const publicPath = chain.output.get("publicPath");
+      const assetPrefix = publicPath && typeof publicPath === "string" ? publicPath : config.output.assetPrefix;
+      const builtinVars = {
+        "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV),
+        "process.env.ASSET_PREFIX": JSON.stringify(
+          (0, import_shared.removeTailSlash)(assetPrefix)
+        )
+      };
+      chain.plugin(CHAIN_ID.PLUGIN.DEFINE).use(bundler.DefinePlugin, [
+        { ...builtinVars, ...config.source.define }
+      ]);
+    });
   }
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/plugins/html.d.ts

@@ -1,4 +1,10 @@
-import type { MetaAttrs, HtmlConfig, MetaOptions, DefaultRsbuildPlugin, SharedRsbuildPluginAPI, NormalizedOutputConfig } from '@rsbuild/shared';
+import type { MetaAttrs, HtmlConfig, MetaOptions, NormalizedConfig, DefaultRsbuildPlugin, SharedRsbuildPluginAPI, NormalizedOutputConfig } from '@rsbuild/shared';
+export declare function getTitle(entryName: string, config: NormalizedConfig): string;
+export declare function getInject(entryName: string, config: NormalizedConfig): import("@rsbuild/shared").ScriptInject;
+export declare function getTemplatePath(entryName: string, config: NormalizedConfig): string;
+export declare function getFavicon(entryName: string, config: {
+  html: HtmlConfig;
+}): string;
 export declare const generateMetaTags: (metaOptions?: MetaOptions) => MetaAttrs[];
 export declare function getMetaTags(entryName: string, config: {
   html: HtmlConfig;

package/dist/plugins/html.js

@@ -30,7 +30,11 @@ var html_exports = {};
 __export(html_exports, {
   applyInjectTags: () => applyInjectTags,
   generateMetaTags: () => generateMetaTags,
+  getFavicon: () => getFavicon,
+  getInject: () => getInject,
   getMetaTags: () => getMetaTags,
+  getTemplatePath: () => getTemplatePath,
+  getTitle: () => getTitle,
   pluginHtml: () => pluginHtml
 });
 module.exports = __toCommonJS(html_exports);
@@ -38,6 +42,43 @@ var import_path = __toESM(require("path"));
 var import_shared = require("@rsbuild/shared");
 var import_fs_extra = require("@rsbuild/shared/fs-extra");
 var import_lodash = __toESM(require("lodash"));
+var import_HtmlBasicPlugin = require("../rspack-plugins/HtmlBasicPlugin");
+function getTitle(entryName, config) {
+  return (0, import_shared.mergeChainedOptions)({
+    defaults: "",
+    options: config.html.title,
+    utils: { entryName },
+    useObjectParam: true
+  });
+}
+function getInject(entryName, config) {
+  return (0, import_shared.mergeChainedOptions)({
+    defaults: "head",
+    options: config.html.inject,
+    utils: { entryName },
+    useObjectParam: true
+  });
+}
+function getTemplatePath(entryName, config) {
+  const DEFAULT_TEMPLATE = import_path.default.resolve(
+    __dirname,
+    "../../static/template.html"
+  );
+  return (0, import_shared.mergeChainedOptions)({
+    defaults: DEFAULT_TEMPLATE,
+    options: config.html.template,
+    utils: { entryName },
+    useObjectParam: true
+  });
+}
+function getFavicon(entryName, config) {
+  return (0, import_shared.mergeChainedOptions)({
+    defaults: "",
+    options: config.html.favicon,
+    utils: { entryName },
+    useObjectParam: true
+  });
+}
 const generateMetaTags = (metaOptions) => {
   if (!metaOptions) {
     return [];
@@ -59,32 +100,29 @@ async function getMetaTags(entryName, config) {
   });
   return generateMetaTags(merged);
 }
-async function getTemplateParameters(entryName, config, assetPrefix) {
-  const { mountId, templateParameters, templateParametersByEntries } = config.html;
-  const templateParams = (templateParametersByEntries == null ? void 0 : templateParametersByEntries[entryName]) || templateParameters;
-  const baseParameters = {
-    mountId,
-    entryName,
-    assetPrefix
-  };
+function getTemplateParameters(entryName, config, assetPrefix) {
   return (compilation, assets, assetTags, pluginOptions) => {
+    const { mountId, templateParameters } = config.html;
     const defaultOptions = {
+      mountId,
+      entryName,
+      assetPrefix,
       compilation,
       webpackConfig: compilation.options,
       htmlWebpackPlugin: {
         tags: assetTags,
         files: assets,
         options: pluginOptions
-      },
-      ...baseParameters
+      }
     };
     return (0, import_shared.mergeChainedOptions)({
       defaults: defaultOptions,
-      options: templateParams
+      options: templateParameters,
+      utils: { entryName }
     });
   };
 }
-async function getChunks(entryName, entryValue) {
+function getChunks(entryName, entryValue) {
   const dependOn = [];
   if ((0, import_shared.isPlainObject)(entryValue)) {
     dependOn.push(...entryValue.dependOn);
@@ -139,36 +177,19 @@ const pluginHtml = () => ({
         const entries = chain.entryPoints.entries() || {};
         const entryNames = Object.keys(entries);
         const htmlPaths = api.getHTMLPaths();
-        const faviconUrls = [];
-        const metaPluginOptions = {
-          meta: {},
-          HtmlPlugin
-        };
-        const titlePluginOptions = {
-          titles: {},
-          HtmlPlugin
-        };
+        const htmlInfoMap = {};
         await Promise.all(
           entryNames.map(async (entryName, index) => {
             const entryValue = entries[entryName].values();
-            const chunks = await getChunks(entryName, entryValue);
-            const inject = (0, import_shared.getInject)(entryName, config);
-            const favicon = (0, import_shared.getFavicon)(entryName, config);
+            const chunks = getChunks(entryName, entryValue);
+            const inject = getInject(entryName, config);
             const filename = htmlPaths[entryName];
-            const template = (0, import_shared.getTemplatePath)(entryName, config);
-            const metaTags = await getMetaTags(entryName, config);
-            const title = await (0, import_shared.getTitle)(entryName, config);
-            const templateParameters = await getTemplateParameters(
+            const template = getTemplatePath(entryName, config);
+            const templateParameters = getTemplateParameters(
               entryName,
               config,
               assetPrefix
             );
-            if (metaTags.length) {
-              metaPluginOptions.meta[filename] = metaTags;
-            }
-            if (title) {
-              titlePluginOptions.titles[filename] = title;
-            }
             const pluginOptions = {
               chunks,
               inject,
@@ -178,12 +199,20 @@ const pluginHtml = () => ({
               templateParameters,
               scriptLoading: config.html.scriptLoading
             };
+            const htmlInfo = {};
+            htmlInfoMap[filename] = htmlInfo;
+            const title = getTitle(entryName, config);
+            if (title) {
+              htmlInfo.title = title;
+            }
+            const metaTags = await getMetaTags(entryName, config);
+            if (metaTags.length) {
+              htmlInfo.meta = metaTags;
+            }
+            const favicon = getFavicon(entryName, config);
             if (favicon) {
               if ((0, import_shared.isURL)(favicon)) {
-                faviconUrls.push({
-                  filename,
-                  url: favicon
-                });
+                htmlInfo.favicon = favicon;
               } else {
                 pluginOptions.favicon = favicon;
               }
@@ -205,12 +234,7 @@ const pluginHtml = () => ({
             chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).use(HtmlPlugin, [finalOptions]);
           })
         );
-        if (Object.keys(metaPluginOptions.meta).length) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_META).use(import_shared.HtmlMetaPlugin, [metaPluginOptions]);
-        }
-        if (Object.keys(titlePluginOptions.titles).length) {
-          chain.plugin(CHAIN_ID.PLUGIN.HTML_TITLE).use(import_shared.HtmlTitlePlugin, [titlePluginOptions]);
-        }
+        chain.plugin(CHAIN_ID.PLUGIN.HTML_BASIC).use(import_HtmlBasicPlugin.HtmlBasicPlugin, [{ HtmlPlugin, info: htmlInfoMap }]);
         if (config.security) {
           const { nonce } = config.security;
           if (nonce) {
@@ -228,10 +252,6 @@ const pluginHtml = () => ({
             ]);
             chain.output.crossOriginLoading(formattedCrossorigin);
           }
-          if (faviconUrls.length) {
-            const { HtmlFaviconUrlPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
-            chain.plugin(CHAIN_ID.PLUGIN.FAVICON_URL).use(HtmlFaviconUrlPlugin, [{ faviconUrls, HtmlPlugin }]);
-          }
           if (appIcon) {
             const { HtmlAppIconPlugin } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared")));
             const distDir = (0, import_shared.getDistPath)(config.output, "image");
@@ -259,6 +279,10 @@ const pluginHtml = () => ({
 0 && (module.exports = {
   applyInjectTags,
   generateMetaTags,
+  getFavicon,
+  getInject,
   getMetaTags,
+  getTemplatePath,
+  getTitle,
   pluginHtml
 });

package/dist/plugins/index.js

@@ -50,7 +50,6 @@ const plugins = {
   font: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("font", import_shared.FONT_EXTENSIONS)),
   image: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("image", import_shared.IMAGE_EXTENSIONS)),
   media: () => Promise.resolve().then(() => __toESM(require("./asset"))).then((m) => m.pluginAsset("media", import_shared.MEDIA_EXTENSIONS)),
-  assetsRetry: () => Promise.resolve().then(() => __toESM(require("./assetsRetry"))).then((m) => m.pluginAssetsRetry()),
   rem: () => Promise.resolve().then(() => __toESM(require("./rem"))).then((m) => m.pluginRem()),
   wasm: () => Promise.resolve().then(() => __toESM(require("./wasm"))).then((m) => m.pluginWasm()),
   moment: () => Promise.resolve().then(() => __toESM(require("./moment"))).then((m) => m.pluginMoment()),

package/dist/plugins/nodeAddons.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,20 +15,13 @@ 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 nodeAddons_exports = {};
 __export(nodeAddons_exports, {
   pluginNodeAddons: () => pluginNodeAddons
 });
 module.exports = __toCommonJS(nodeAddons_exports);
+var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 const pluginNodeAddons = () => ({
   name: "plugin-node-addons",
@@ -40,19 +31,21 @@ const pluginNodeAddons = () => ({
         if (!isServer && !isServiceWorker) {
           return;
         }
-        const pkgUp = await Promise.resolve().then(() => __toESM(require("pkg-up")));
-        const getDistName = (resource) => {
-          const pkgJSON = pkgUp.sync({ cwd: resource });
+        const getDistName = (resourcePath) => {
+          const pkgJSON = (0, import_shared.findUpSync)({
+            filename: "package.json",
+            cwd: (0, import_path.dirname)(resourcePath)
+          });
           if (!pkgJSON) {
             throw new Error(
               `Failed to compile Node.js addons, couldn't find the package.json of ${import_shared.color.yellow(
-                resource
+                resourcePath
               )}.`
             );
           }
-          const getFilename = (resource2, pkgName2) => {
+          const getFilename = (resource, pkgName2) => {
             const reg = new RegExp(`node_modules/${pkgName2}/(.+)`);
-            const match = resource2.match(reg);
+            const match = resource.match(reg);
             const filename = match == null ? void 0 : match[1];
             if (!filename) {
               return "[name].[ext]";
@@ -62,7 +55,7 @@ const pluginNodeAddons = () => ({
           const { name: pkgName } = require(pkgJSON);
           const config = api.getNormalizedConfig();
           const serverPath = (0, import_shared.getDistPath)(config.output, "server");
-          return `${serverPath}/${getFilename(resource, pkgName)}`;
+          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({
           name: getDistName

package/dist/plugins/startUrl.js

@@ -36,6 +36,8 @@ module.exports = __toCommonJS(startUrl_exports);
 var import_path = require("path");
 var import_shared = require("@rsbuild/shared");
 var import_child_process = require("child_process");
+var import_util = require("util");
+const execAsync = (0, import_util.promisify)(import_child_process.exec);
 const supportedChromiumBrowsers = [
   "Google Chrome Canary",
   "Google Chrome Dev",
@@ -46,10 +48,10 @@ const supportedChromiumBrowsers = [
   "Vivaldi",
   "Chromium"
 ];
-const getTargetBrowser = () => {
+const getTargetBrowser = async () => {
   let targetBrowser = process.env.BROWSER;
   if (!targetBrowser || !supportedChromiumBrowsers.includes(targetBrowser)) {
-    const ps = (0, import_child_process.execSync)("ps cax").toString();
+    const { stdout: ps } = await execAsync("ps cax");
     targetBrowser = supportedChromiumBrowsers.find((b) => ps.includes(b));
   }
   return targetBrowser;
@@ -58,14 +60,13 @@ async function openBrowser(url) {
   const shouldTryOpenChromeWithAppleScript = process.platform === "darwin";
   if (shouldTryOpenChromeWithAppleScript) {
     try {
-      const targetBrowser = getTargetBrowser();
+      const targetBrowser = await getTargetBrowser();
       if (targetBrowser) {
-        (0, import_child_process.execSync)(
+        await execAsync(
           `osascript openChrome.applescript "${encodeURI(
             url
           )}" "${targetBrowser}"`,
           {
-            stdio: "ignore",
             cwd: (0, import_path.join)(__dirname, "../../static")
           }
         );
@@ -93,23 +94,18 @@ const openedURLs = [];
 function pluginStartUrl() {
   return {
     name: "plugin-start-url",
-    async setup(api) {
-      let port;
+    setup(api) {
       api.onAfterStartDevServer(async (params) => {
-        ({ port } = params);
-      });
-      api.onDevCompileDone(async ({ isFirstCompile }) => {
-        if (!isFirstCompile || !port) {
-          return;
-        }
+        const { port } = params;
         const config = api.getNormalizedConfig();
         const { startUrl, beforeStartUrl } = config.dev;
-        const { https } = api.context.devServer || {};
-        if (!startUrl) {
+        const { open, https } = api.context.devServer || {};
+        const shouldOpen = Boolean(startUrl) || open;
+        if (!shouldOpen) {
           return;
         }
         const urls = [];
-        if (startUrl === true) {
+        if (startUrl === true || !startUrl) {
           const protocol = https ? "https" : "http";
           urls.push(`${protocol}://localhost:${port}`);
         } else {

package/dist/rspack-plugins/HtmlBasicPlugin.d.ts

@@ -0,0 +1,19 @@
+import type HtmlWebpackPlugin from 'html-webpack-plugin';
+import type { Compiler } from '@rspack/core';
+import type { MetaAttrs } from '@rsbuild/shared';
+export type HtmlInfo = {
+  meta?: MetaAttrs[];
+  title?: string;
+  favicon?: string;
+};
+export type HtmlBasicPluginOptions = {
+  info: Record<string, HtmlInfo>;
+  HtmlPlugin: typeof HtmlWebpackPlugin;
+};
+export declare class HtmlBasicPlugin {
+  readonly name: string;
+  readonly options: HtmlBasicPluginOptions;
+  readonly HtmlPlugin: typeof HtmlWebpackPlugin;
+  constructor(options: HtmlBasicPluginOptions);
+  apply(compiler: Compiler): void;
+}

package/dist/rspack-plugins/HtmlBasicPlugin.js

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var HtmlBasicPlugin_exports = {};
+__export(HtmlBasicPlugin_exports, {
+  HtmlBasicPlugin: () => HtmlBasicPlugin
+});
+module.exports = __toCommonJS(HtmlBasicPlugin_exports);
+class HtmlBasicPlugin {
+  constructor(options) {
+    this.name = "HtmlBasicPlugin";
+    this.options = options;
+    this.HtmlPlugin = options.HtmlPlugin;
+  }
+  apply(compiler) {
+    const addTitleTag = (headTags, outputName) => {
+      const { title } = this.options.info[outputName];
+      if (title) {
+        headTags.unshift({
+          tagName: "title",
+          innerHTML: title,
+          attributes: {},
+          voidTag: false,
+          meta: {}
+        });
+      }
+    };
+    const addMetaTag = (headTags, outputName) => {
+      const { meta } = this.options.info[outputName];
+      if (meta) {
+        headTags.unshift(
+          ...meta.map((attr) => ({
+            tagName: "meta",
+            attributes: attr,
+            meta: {},
+            voidTag: true
+          }))
+        );
+      }
+    };
+    const addFavicon = (headTags, outputName) => {
+      const { favicon } = this.options.info[outputName];
+      if (favicon) {
+        headTags.unshift({
+          tagName: "link",
+          voidTag: true,
+          attributes: {
+            rel: "icon",
+            href: favicon
+          },
+          meta: {}
+        });
+      }
+    };
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      this.HtmlPlugin.getHooks(compilation).alterAssetTagGroups.tap(
+        this.name,
+        (data) => {
+          const { headTags, outputName } = data;
+          addTitleTag(headTags, outputName);
+          addMetaTag(headTags, outputName);
+          addFavicon(headTags, outputName);
+          return data;
+        }
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HtmlBasicPlugin
+});

package/dist/rspack-provider/core/createCompiler.js

@@ -43,16 +43,18 @@ async function createCompiler({
   const { rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
   const compiler = rspack(rspackConfigs);
   let isFirstCompile = true;
-  compiler.hooks.done.tap("done", async (stats) => {
-    var _a;
+  compiler.hooks.watchRun.tap("rsbuild:compiling", () => {
+    import_shared.logger.start("Compiling...");
+  });
+  compiler.hooks.done.tap("rsbuild:done", async (stats) => {
     const obj = stats.toJson({
       all: false,
       timings: true
     });
-    if (!stats.hasErrors()) {
-      (_a = obj.children) == null ? void 0 : _a.forEach((c, index) => {
+    if (!stats.hasErrors() && obj.children) {
+      obj.children.forEach((c, index) => {
         if (c.time) {
-          const time = (0, import_shared.prettyTime)([0, c.time * 10 ** 6]);
+          const time = (0, import_shared.prettyTime)(c.time / 1e3);
           const target = Array.isArray(context.target) ? context.target[index] : context.target;
           const name = import_shared.TARGET_ID_MAP[target || "web"];
           import_shared.logger.ready(`${name} compiled in ${time}`);

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

@@ -1,5 +1,3 @@
-import type { ModernDevServerOptions } from '@modern-js/server';
+import { DevMiddleware } from '@rsbuild/shared';
 import type { Compiler, MultiCompiler } from '@rspack/core';
-type DevMiddlewareOptions = ModernDevServerOptions['devMiddleware'];
-export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => NonNullable<DevMiddlewareOptions>;
-export {};
+export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => NonNullable<DevMiddleware>;

package/dist/rspack-provider/core/startDevServer.d.ts

@@ -1,6 +1,5 @@
 import { StartDevServerOptions, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
 import { type InitConfigsOptions } from './initConfigs';
 type ServerOptions = Exclude<StartDevServerOptions['serverOptions'], undefined>;
-export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: ServerOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@modern-js/server").Server>;
-export declare function startDevServer(options: InitConfigsOptions, startDevServerOptions?: StartDevServerOptions): Promise<import("@rsbuild/shared").StartServerResult>;
+export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: ServerOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").ServerApi>;
 export {};