@rsbuild/core 0.0.18 → 0.0.19

package/bin/rsbuild.js

@@ -1,7 +1,18 @@
 #!/usr/bin/env node
 const { logger } = require('rslog');
 
+function initNodeEnv() {
+  if (!process.env.NODE_ENV) {
+    const command = process.argv[2];
+    process.env.NODE_ENV = ['build', 'preview'].includes(command)
+      ? 'production'
+      : 'development';
+  }
+}
+
 async function main() {
+  initNodeEnv();
+
   const { version } = require('../package.json');
 
   // If not called through a package manager,

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

@@ -1,4 +1,6 @@
 import { type RspackConfig } from '@rsbuild/shared';
+import { type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import { type InitConfigsOptions } from './initConfigs';
 import type { Context } from '../types';
 export declare function createCompiler({
   context,
@@ -6,4 +8,5 @@ export declare function createCompiler({
 }: {
   context: Context;
   rspackConfigs: RspackConfig[];
-}): Promise<import("@rspack/core").MultiCompiler>;
+}): Promise<import("@rspack/core").MultiCompiler>;
+export declare function startDevCompile(options: InitConfigsOptions, customCompiler?: RspackCompiler | RspackMultiCompiler): Promise<import("@rsbuild/shared").DevMiddleware>;

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

@@ -28,10 +28,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var createCompiler_exports = {};
 __export(createCompiler_exports, {
-  createCompiler: () => createCompiler
+  createCompiler: () => createCompiler,
+  startDevCompile: () => startDevCompile
 });
 module.exports = __toCommonJS(createCompiler_exports);
 var import_shared = require("@rsbuild/shared");
+var import_devMiddleware = require("./devMiddleware");
+var import_initConfigs = require("./initConfigs");
 async function createCompiler({
   context,
   rspackConfigs
@@ -79,7 +82,21 @@ async function createCompiler({
   (0, import_shared.debug)("create compiler done");
   return compiler;
 }
+async function startDevCompile(options, customCompiler) {
+  let compiler;
+  if (customCompiler) {
+    compiler = customCompiler;
+  } else {
+    const { rspackConfigs } = await (0, import_initConfigs.initConfigs)(options);
+    compiler = await createCompiler({
+      context: options.context,
+      rspackConfigs
+    });
+  }
+  return (0, import_devMiddleware.getDevMiddleware)(compiler);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createCompiler
+  createCompiler,
+  startDevCompile
 });

package/dist/rspack-provider/provider.js

@@ -73,10 +73,10 @@ function rspackProvider({
         });
       },
       async startDevServer(options) {
-        const { createDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
-        return (0, import_shared.startDevServer)(
+        const { startDevCompile } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        return (0, import_server.startDevServer)(
           { context, pluginStore, rsbuildOptions },
-          createDevServer,
+          startDevCompile,
           options
         );
       },

package/dist/server/devServer.d.ts

@@ -3,7 +3,7 @@
 /// <reference types="node" />
 import { Server } from 'http';
 import type { ListenOptions } from 'net';
-import { RsbuildDevServerOptions, CreateDevServerOptions, ServerApi } from '@rsbuild/shared';
+import { RsbuildDevServerOptions, CreateDevServerOptions, DevServerContext, StartDevServerOptions, StartServerResult } from '@rsbuild/shared';
 import connect from 'connect';
 export declare class RsbuildDevServer {
   private readonly dev;
@@ -17,7 +17,19 @@ export declare class RsbuildDevServer {
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
   createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | import("https").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
-  listen(options?: number | ListenOptions | undefined, listener?: () => void): void;
+  listen(options?: number | ListenOptions | undefined, listener?: (err?: Error) => Promise<void>): void;
   close(): void;
 }
-export declare function createDevServer(options: CreateDevServerOptions): Promise<ServerApi>;
+export declare function startDevServer<Options extends {
+  context: DevServerContext;
+}>(options: Options, startDevCompile: (options: Options, compiler: StartDevServerOptions['compiler']) => Promise<CreateDevServerOptions['devMiddleware']>, {
+  open,
+  compiler,
+  printURLs,
+  strictPort,
+  serverOptions,
+  logger: customLogger,
+  getPortSilently
+}?: StartDevServerOptions & {
+  defaultPort?: number;
+}): Promise<StartServerResult>;

package/dist/server/devServer.js

@@ -29,7 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var devServer_exports = {};
 __export(devServer_exports, {
   RsbuildDevServer: () => RsbuildDevServer,
-  createDevServer: () => createDevServer
+  startDevServer: () => startDevServer
 });
 module.exports = __toCommonJS(devServer_exports);
 var import_http = require("http");
@@ -40,6 +40,8 @@ var import_constants = require("./constants");
 var import_dev_middleware = __toESM(require("./dev-middleware"));
 var import_deepmerge = require("@rsbuild/shared/deepmerge");
 var import_connect = __toESM(require("connect"));
+var import_proxy = require("./proxy");
+var import_middlewares = require("./middlewares");
 class RsbuildDevServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
@@ -106,6 +108,13 @@ class RsbuildDevServer {
       }
       next();
     });
+    if (dev.proxy) {
+      const { middlewares, handleUpgrade } = (0, import_proxy.createProxyMiddleware)(dev.proxy);
+      app && handleUpgrade(app);
+      middlewares.forEach((middleware) => {
+        this.middlewares.use(middleware);
+      });
+    }
     devMiddleware.init(app);
     devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
     if (dev.historyApiFallback) {
@@ -117,6 +126,7 @@ class RsbuildDevServer {
       this.middlewares.use(historyApiFallbackMiddleware);
       devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
     }
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
   }
   async createHTTPServer() {
     const { dev } = this;
@@ -143,30 +153,83 @@ class RsbuildDevServer {
     this.app.close();
   }
 }
-async function createDevServer(options) {
+async function startDevServer(options, startDevCompile, {
+  open,
+  compiler,
+  printURLs = true,
+  strictPort = false,
+  serverOptions = {},
+  logger: customLogger,
+  getPortSilently
+} = {}) {
   var _a;
-  const { server: serverOptions = {}, ...devOptions } = options;
-  const logger = (_a = serverOptions.logger) != null ? _a : import_shared.logger;
-  const devServer = new RsbuildDevServer(devOptions);
-  const httpServer = serverOptions.customApp || await devServer.createHTTPServer();
-  const server = {
-    middlewares: devServer.middlewares,
-    init: async () => {
-      await devServer.onInit(httpServer);
-    },
-    // resolvedConfig,
-    listen: (options2, cb) => {
-      devServer.listen(options2, cb);
-    },
-    logger,
-    close: () => {
-      devServer.close();
-    }
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "development";
+  }
+  const rsbuildConfig = options.context.config;
+  const logger = customLogger != null ? customLogger : import_shared.logger;
+  const { devServerConfig, port, host, https } = await (0, import_shared.getDevOptions)({
+    rsbuildConfig,
+    serverOptions,
+    strictPort,
+    getPortSilently
+  });
+  options.context.devServer = {
+    hostname: host,
+    port,
+    https,
+    open
   };
-  return server;
+  const protocol = https ? "https" : "http";
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, (_a = rsbuildConfig.dev) == null ? void 0 : _a.host);
+  if (printURLs) {
+    if ((0, import_shared.isFunction)(printURLs)) {
+      urls = printURLs(urls);
+      if (!Array.isArray(urls)) {
+        throw new Error("Please return an array in the `printURLs` function.");
+      }
+    }
+    (0, import_shared.printServerURLs)(urls, logger);
+  }
+  (0, import_shared.debug)("create dev server");
+  const devMiddleware = await startDevCompile(options, compiler);
+  const server = new RsbuildDevServer({
+    pwd: options.context.rootPath,
+    devMiddleware,
+    dev: devServerConfig
+  });
+  (0, import_shared.debug)("create dev server done");
+  await options.context.hooks.onBeforeStartDevServerHook.call();
+  const httpServer = await server.createHTTPServer();
+  await server.onInit(httpServer);
+  (0, import_shared.debug)("listen dev server");
+  return new Promise((resolve) => {
+    server.listen(
+      {
+        host,
+        port
+      },
+      async (err) => {
+        if (err) {
+          throw err;
+        }
+        (0, import_shared.debug)("listen dev server done");
+        await options.context.hooks.onAfterStartDevServerHook.call({ port });
+        resolve({
+          port,
+          urls: urls.map((item) => item.url),
+          server: {
+            close: () => {
+              server.close();
+            }
+          }
+        });
+      }
+    );
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RsbuildDevServer,
-  createDevServer
+  startDevServer
 });

package/dist/server/index.d.ts

@@ -1,2 +1,2 @@
-export { createDevServer } from './devServer';
+export { startDevServer } from './devServer';
 export { startProdServer } from './prodServer';

package/dist/server/index.js

@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var server_exports = {};
 __export(server_exports, {
-  createDevServer: () => import_devServer.createDevServer,
+  startDevServer: () => import_devServer.startDevServer,
   startProdServer: () => import_prodServer.startProdServer
 });
 module.exports = __toCommonJS(server_exports);
@@ -26,6 +26,6 @@ var import_devServer = require("./devServer");
 var import_prodServer = require("./prodServer");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDevServer,
+  startDevServer,
   startProdServer
 });

package/dist/server/middlewares.d.ts

@@ -0,0 +1,2 @@
+import { RequestHandler as Middleware } from '@rsbuild/shared';
+export declare const faviconFallbackMiddleware: Middleware;

package/dist/server/middlewares.js

@@ -0,0 +1,35 @@
+"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 middlewares_exports = {};
+__export(middlewares_exports, {
+  faviconFallbackMiddleware: () => faviconFallbackMiddleware
+});
+module.exports = __toCommonJS(middlewares_exports);
+const faviconFallbackMiddleware = (req, res, next) => {
+  if (req.url === "/favicon.ico") {
+    res.statusCode = 204;
+    res.end();
+  } else {
+    next();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  faviconFallbackMiddleware
+});

package/dist/server/prodServer.d.ts

@@ -18,6 +18,7 @@ export declare class RsbuildProdServer {
   constructor(options: RsbuildProdServerOptions);
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
+  private applyStaticAssetMiddleware;
   createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
   listen(options?: number | ListenOptions | undefined, listener?: () => void): void;
   close(): void;

package/dist/server/prodServer.js

@@ -37,6 +37,7 @@ var import_connect = __toESM(require("connect"));
 var import_path = require("path");
 var import_sirv = __toESM(require("sirv"));
 var import_shared = require("@rsbuild/shared");
+var import_middlewares = require("./middlewares");
 class RsbuildProdServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
@@ -48,6 +49,10 @@ class RsbuildProdServer {
     await this.applyDefaultMiddlewares();
   }
   async applyDefaultMiddlewares() {
+    this.applyStaticAssetMiddleware();
+    this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
+  }
+  applyStaticAssetMiddleware() {
     const {
       output: { path, assetPrefix },
       pwd
@@ -115,11 +120,9 @@ async function startProdServer(context, rsbuildConfig) {
           port,
           urls: urls.map((item) => item.url),
           server: {
-            middlewares: server.middlewares,
             close: () => {
               server.close();
             }
-            // TODO: decouple with Modern.js server
           }
         });
       }

package/dist/server/proxy.d.ts

@@ -0,0 +1,9 @@
+import http from 'http';
+import { RequestHandler } from 'http-proxy-middleware';
+import { ProxyDetail, RequestHandler as Middleware, RsbuildProxyOptions } from '@rsbuild/shared';
+export declare function formatProxyOptions(proxyOptions: RsbuildProxyOptions): ProxyDetail[];
+export type HttpUpgradeHandler = NonNullable<RequestHandler['upgrade']>;
+export declare const createProxyMiddleware: (proxyOptions: RsbuildProxyOptions) => {
+  middlewares: Middleware[];
+  handleUpgrade: (server: http.Server) => void;
+};

package/dist/server/proxy.js

@@ -0,0 +1,92 @@
+"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 proxy_exports = {};
+__export(proxy_exports, {
+  createProxyMiddleware: () => createProxyMiddleware,
+  formatProxyOptions: () => formatProxyOptions
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_http_proxy_middleware2 = require("http-proxy-middleware/dist/http-proxy-middleware");
+function formatProxyOptions(proxyOptions) {
+  var _a;
+  const ret = [];
+  if (Array.isArray(proxyOptions)) {
+    ret.push(...proxyOptions);
+  } else if ("target" in proxyOptions) {
+    ret.push(proxyOptions);
+  } else {
+    for (const [context, options] of Object.entries(proxyOptions)) {
+      const opts = {
+        context,
+        changeOrigin: true,
+        logLevel: "warn"
+      };
+      if (typeof options === "string") {
+        opts.target = options;
+      } else {
+        Object.assign(opts, options);
+      }
+      ret.push(opts);
+    }
+  }
+  const handleError = (err, _req, _res, _target) => {
+    console.error(err);
+  };
+  for (const opts of ret) {
+    (_a = opts.onError) != null ? _a : opts.onError = handleError;
+  }
+  return ret;
+}
+const createProxyMiddleware = (proxyOptions) => {
+  const formattedOptionsList = formatProxyOptions(proxyOptions);
+  const proxies = [];
+  const middlewares = [];
+  for (const opts of formattedOptionsList) {
+    const proxy = new import_http_proxy_middleware2.HttpProxyMiddleware(opts.context, opts);
+    const middleware = async (req, res, next) => {
+      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
+      if (typeof bypassUrl === "boolean") {
+        res.statusCode = 404;
+        next();
+      } else if (typeof bypassUrl === "string") {
+        req.url = bypassUrl;
+        next();
+      } else {
+        proxy.middleware(req, res, next);
+      }
+    };
+    proxies.push(proxy);
+    middlewares.push(middleware);
+  }
+  const handleUpgrade = (server) => {
+    for (const proxy of proxies) {
+      const raw = proxy;
+      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
+        server.on("upgrade", raw.handleUpgrade);
+        raw.wsInternalSubscribed = true;
+      }
+    }
+  };
+  return { middlewares, handleUpgrade };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProxyMiddleware,
+  formatProxyOptions
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -88,6 +88,7 @@
     "gzip-size": "^6.0.0",
     "html-webpack-plugin": "5.5.3",
     "http-compression": "1.0.6",
+    "http-proxy-middleware": "^2.0.1",
     "jiti": "^1.20.0",
     "lodash": "^4.17.21",
     "open": "^8.4.0",
@@ -97,7 +98,7 @@
     "sirv": "^2.0.3",
     "strip-ansi": "^6.0.1",
     "ws": "^8.2.0",
-    "@rsbuild/shared": "0.0.18"
+    "@rsbuild/shared": "0.0.19"
   },
   "devDependencies": {
     "@types/connect": "3.4.35",

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

@@ -1,5 +0,0 @@
-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("@rsbuild/shared").ServerApi>;
-export {};

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

@@ -1,59 +0,0 @@
-"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 startDevServer_exports = {};
-__export(startDevServer_exports, {
-  createDevServer: () => createDevServer
-});
-module.exports = __toCommonJS(startDevServer_exports);
-var import_shared = require("@rsbuild/shared");
-var import_createCompiler = require("./createCompiler");
-var import_devMiddleware = require("./devMiddleware");
-var import_initConfigs = require("./initConfigs");
-var import_server = require("../../server");
-async function createDevServer(options, port, serverOptions, customCompiler) {
-  let compiler;
-  if (customCompiler) {
-    compiler = customCompiler;
-  } else {
-    const { rspackConfigs } = await (0, import_initConfigs.initConfigs)(options);
-    compiler = await (0, import_createCompiler.createCompiler)({
-      context: options.context,
-      rspackConfigs
-    });
-  }
-  (0, import_shared.debug)("create dev server");
-  const rsbuildConfig = options.context.config;
-  const { devConfig } = await (0, import_shared.getDevServerOptions)({
-    rsbuildConfig,
-    serverOptions,
-    port
-  });
-  const server = await (0, import_server.createDevServer)({
-    pwd: options.context.rootPath,
-    devMiddleware: (0, import_devMiddleware.getDevMiddleware)(compiler),
-    ...serverOptions,
-    dev: devConfig
-  });
-  (0, import_shared.debug)("create dev server done");
-  return server;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createDevServer
-});