@rsbuild/core 0.0.28 → 0.1.1

package/dist/server/devServer.js

@@ -50,6 +50,7 @@ class RsbuildDevServer {
     this.output = options.output;
     this.devMiddleware = new import_dev_middleware.default({
       dev: this.dev,
+      publicPaths: options.output.publicPaths,
       devMiddleware: options.devMiddleware
     });
   }
@@ -116,14 +117,14 @@ class RsbuildDevServer {
     this.middlewares.use(
       (0, import_middlewares.getHtmlFallbackMiddleware)({
         distPath: (0, import_path.isAbsolute)(distPath) ? distPath : (0, import_path.join)(this.pwd, distPath),
-        publicPath: this.output.publicPath,
-        callback: devMiddleware.middleware
+        callback: devMiddleware.middleware,
+        htmlFallback: this.dev.htmlFallback
       })
     );
     if (dev.historyApiFallback) {
       const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("../../compiled/connect-history-api-fallback")));
       const historyApiFallbackMiddleware = connectHistoryApiFallback(
-        typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
+        dev.historyApiFallback === true ? {} : dev.historyApiFallback
       );
       this.middlewares.use(historyApiFallbackMiddleware);
       devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
@@ -135,9 +136,7 @@ class RsbuildDevServer {
     const { dev } = this;
     const devHttpsOption = typeof dev === "object" && dev.https;
     if (devHttpsOption) {
-      const { genHttpsOptions } = require("./https");
-      const httpsOptions = await genHttpsOptions(devHttpsOption, this.pwd);
-      return (0, import_https.createServer)(httpsOptions, this.middlewares);
+      return (0, import_https.createServer)(devHttpsOption, this.middlewares);
     } else {
       return (0, import_http.createServer)(this.middlewares);
     }
@@ -165,7 +164,7 @@ async function startDevServer(options, createDevMiddleware, {
   logger: customLogger,
   getPortSilently
 } = {}) {
-  var _a, _b, _c, _d, _e;
+  var _a, _b, _c, _d;
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "development";
   }
@@ -183,24 +182,24 @@ async function startDevServer(options, createDevMiddleware, {
     open
   };
   const protocol = https ? "https" : "http";
-  let urls = (0, import_shared.getAddressUrls)(protocol, port, (_a = rsbuildConfig.dev) == null ? void 0 : _a.host);
+  let urls = (0, import_shared.getAddressUrls)(protocol, port, host);
   const routes = (0, import_shared.formatRoutes)(
     options.context.entry,
-    (_c = (_b = rsbuildConfig.output) == null ? void 0 : _b.distPath) == null ? void 0 : _c.html
+    (_b = (_a = rsbuildConfig.output) == null ? void 0 : _a.distPath) == null ? void 0 : _b.html
   );
   (0, import_shared.debug)("create dev server");
   const { devMiddleware, compiler } = await createDevMiddleware(
     options,
     customCompiler
   );
-  const publicPath = compiler.compilers ? (0, import_shared.getPublicPathFromCompiler)(compiler.compilers[0]) : (0, import_shared.getPublicPathFromCompiler)(compiler);
+  const publicPaths = compiler.compilers ? compiler.compilers.map(import_shared.getPublicPathFromCompiler) : [(0, import_shared.getPublicPathFromCompiler)(compiler)];
   const server = new RsbuildDevServer({
     pwd: options.context.rootPath,
     devMiddleware,
     dev: devServerConfig,
     output: {
-      distPath: ((_e = (_d = rsbuildConfig.output) == null ? void 0 : _d.distPath) == null ? void 0 : _e.root) || import_shared.ROOT_DIST_DIR,
-      publicPath
+      distPath: ((_d = (_c = rsbuildConfig.output) == null ? void 0 : _c.distPath) == null ? void 0 : _d.root) || import_shared.ROOT_DIST_DIR,
+      publicPaths
     }
   });
   (0, import_shared.debug)("create dev server done");

package/dist/server/middlewares.d.ts

@@ -1,8 +1,8 @@
-import { RequestHandler as Middleware } from '@rsbuild/shared';
+import { RequestHandler as Middleware, HtmlFallback } from '@rsbuild/shared';
 export declare const faviconFallbackMiddleware: Middleware;
 export declare const notFoundMiddleware: Middleware;
 export declare const getHtmlFallbackMiddleware: (params: {
   distPath: string;
-  publicPath: string;
   callback?: Middleware;
+  htmlFallback?: HtmlFallback;
 }) => Middleware;

package/dist/server/middlewares.js

@@ -48,14 +48,14 @@ const notFoundMiddleware = (_req, res, _next) => {
   res.statusCode = 404;
   res.end();
 };
-const getHtmlFallbackMiddleware = ({ publicPath, distPath, callback }) => {
+const getHtmlFallbackMiddleware = ({ htmlFallback, distPath, callback }) => {
   return (req, res, next) => {
     if (
       // Only accept GET or HEAD
       req.method !== "GET" && req.method !== "HEAD" || // Require Accept header
       !req.headers || typeof req.headers.accept !== "string" || // Ignore JSON requests
       req.headers.accept.includes("application/json") || // Require Accept: text/html or */*
-      !(req.headers.accept.includes("text/html") || req.headers.accept.includes("*/*")) || !req.url
+      !(req.headers.accept.includes("text/html") || req.headers.accept.includes("*/*")) || !req.url || ["/favicon.ico"].includes(req.url)
     ) {
       return next();
     }
@@ -66,31 +66,38 @@ const getHtmlFallbackMiddleware = ({ publicPath, distPath, callback }) => {
       const { devMiddleware } = res.locals.webpack;
       outputFileSystem = devMiddleware.outputFileSystem;
     }
-    const tryRewrite = (filePath, newUrl) => {
+    const rewrite = (newUrl) => {
       var _a;
-      if (outputFileSystem.existsSync(filePath) && callback) {
-        newUrl = (0, import_shared.urlJoin)(publicPath, newUrl);
-        (_a = import_shared.debug) == null ? void 0 : _a(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
-        req.url = newUrl;
+      (_a = import_shared.debug) == null ? void 0 : _a(`Rewriting ${req.method} ${req.url} to ${newUrl}`);
+      req.url = newUrl;
+      if (callback) {
         return callback(req, res, (...args) => {
-          req.url = url;
           next(...args);
         });
+      } else {
+        return next();
       }
     };
     if (pathname.endsWith("/")) {
       const newUrl = url + "index.html";
       const filePath = import_path.default.join(distPath, pathname, "index.html");
-      tryRewrite(filePath, newUrl);
+      if (outputFileSystem.existsSync(filePath)) {
+        return rewrite(newUrl);
+      }
     } else if (
       // '/main' => '/main.html'
       !pathname.endsWith(".html")
     ) {
       const newUrl = url + ".html";
       const filePath = import_path.default.join(distPath, pathname + ".html");
-      tryRewrite(filePath, newUrl);
-    } else {
-      tryRewrite(import_path.default.join(distPath, pathname), url);
+      if (outputFileSystem.existsSync(filePath)) {
+        return rewrite(newUrl);
+      }
+    }
+    if (htmlFallback === "index") {
+      if (outputFileSystem.existsSync(import_path.default.join(distPath, "index.html"))) {
+        return rewrite("/index.html");
+      }
     }
     next();
   };

package/dist/server/prodServer.d.ts

@@ -1,9 +1,10 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import type { ListenOptions } from 'net';
 import { Server } from 'http';
 import connect from '@rsbuild/shared/connect';
-import { Context, RsbuildConfig, StartServerResult, PreviewServerOptions, ServerConfig } from '@rsbuild/shared';
+import { type Context, type ServerConfig, type RsbuildConfig, type StartServerResult, type PreviewServerOptions } from '@rsbuild/shared';
 type RsbuildProdServerOptions = {
   pwd: string;
   output: {
@@ -20,11 +21,13 @@ export declare class RsbuildProdServer {
   onInit(app: Server): Promise<void>;
   private applyDefaultMiddlewares;
   private applyStaticAssetMiddleware;
-  createHTTPServer(): Promise<Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+  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;
   close(): void;
 }
 export declare function startProdServer(context: Context, rsbuildConfig: RsbuildConfig, {
-  printURLs
+  printURLs,
+  strictPort,
+  getPortSilently
 }?: PreviewServerOptions): Promise<StartServerResult>;
 export {};

package/dist/server/prodServer.js

@@ -33,11 +33,13 @@ __export(prodServer_exports, {
 });
 module.exports = __toCommonJS(prodServer_exports);
 var import_http = require("http");
+var import_https = require("https");
 var import_connect = __toESM(require("@rsbuild/shared/connect"));
 var import_path = require("path");
 var import_sirv = __toESM(require("../../compiled/sirv"));
 var import_shared = require("@rsbuild/shared");
 var import_middlewares = require("./middlewares");
+var import_proxy = require("./proxy");
 class RsbuildProdServer {
   constructor(options) {
     this.middlewares = (0, import_connect.default)();
@@ -49,7 +51,16 @@ class RsbuildProdServer {
     await this.applyDefaultMiddlewares();
   }
   async applyDefaultMiddlewares() {
-    const { headers } = this.options.serverConfig;
+    const { headers, proxy, historyApiFallback, compress } = this.options.serverConfig;
+    if (compress) {
+      const { default: compression } = await Promise.resolve().then(() => __toESM(require("../../compiled/http-compression")));
+      this.middlewares.use((req, res, next) => {
+        compression({
+          gzip: true,
+          brotli: false
+        })(req, res, next);
+      });
+    }
     if (headers) {
       this.middlewares.use((_req, res, next) => {
         for (const [key, value] of Object.entries(headers)) {
@@ -58,18 +69,34 @@ class RsbuildProdServer {
         next();
       });
     }
+    if (proxy) {
+      const { middlewares } = (0, import_proxy.createProxyMiddleware)(proxy, this.app);
+      middlewares.forEach((middleware) => {
+        this.middlewares.use(middleware);
+      });
+    }
     this.applyStaticAssetMiddleware();
+    if (historyApiFallback) {
+      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("../../compiled/connect-history-api-fallback")));
+      const historyApiFallbackMiddleware = connectHistoryApiFallback(
+        historyApiFallback === true ? {} : historyApiFallback
+      );
+      this.middlewares.use(historyApiFallbackMiddleware);
+      this.applyStaticAssetMiddleware();
+    }
     this.middlewares.use(import_middlewares.faviconFallbackMiddleware);
   }
   applyStaticAssetMiddleware() {
     const {
       output: { path, assetPrefix },
+      serverConfig: { htmlFallback },
       pwd
     } = this.options;
     const assetMiddleware = (0, import_sirv.default)((0, import_path.join)(pwd, path), {
       etag: true,
       dev: true,
-      ignores: false
+      ignores: ["favicon.ico"],
+      single: htmlFallback === "index"
     });
     this.middlewares.use((req, res, next) => {
       const url = req.url;
@@ -85,7 +112,13 @@ class RsbuildProdServer {
     });
   }
   async createHTTPServer() {
-    return (0, import_http.createServer)(this.middlewares);
+    const { serverConfig } = this.options;
+    const httpsOption = serverConfig.https;
+    if (httpsOption) {
+      return (0, import_https.createServer)(httpsOption, this.middlewares);
+    } else {
+      return (0, import_http.createServer)(this.middlewares);
+    }
   }
   listen(options, listener) {
     const callback = () => {
@@ -101,31 +134,39 @@ class RsbuildProdServer {
     this.app.close();
   }
 }
-async function startProdServer(context, rsbuildConfig, { printURLs = true } = {}) {
-  var _a, _b, _c, _d;
+async function startProdServer(context, rsbuildConfig, {
+  printURLs = true,
+  strictPort = false,
+  getPortSilently
+} = {}) {
+  var _a, _b, _c;
   if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = "production";
   }
-  const port = await (0, import_shared.getPort)(((_a = rsbuildConfig.dev) == null ? void 0 : _a.port) || import_shared.DEFAULT_PORT);
+  const { serverConfig, port, host, https } = await (0, import_shared.getServerOptions)({
+    rsbuildConfig,
+    strictPort,
+    getPortSilently
+  });
   const server = new RsbuildProdServer({
     pwd: context.rootPath,
     output: {
-      path: ((_c = (_b = rsbuildConfig.output) == null ? void 0 : _b.distPath) == null ? void 0 : _c.root) || import_shared.ROOT_DIST_DIR,
-      assetPrefix: (_d = rsbuildConfig.output) == null ? void 0 : _d.assetPrefix
+      path: ((_b = (_a = rsbuildConfig.output) == null ? void 0 : _a.distPath) == null ? void 0 : _b.root) || import_shared.ROOT_DIST_DIR,
+      assetPrefix: (_c = rsbuildConfig.output) == null ? void 0 : _c.assetPrefix
     },
-    serverConfig: rsbuildConfig.server || {}
+    serverConfig
   });
   const httpServer = await server.createHTTPServer();
   await server.onInit(httpServer);
   return new Promise((resolve) => {
     server.listen(
       {
-        host: import_shared.DEFAULT_DEV_HOST,
+        host,
         port
       },
       () => {
         var _a2, _b2;
-        const urls = (0, import_shared.getAddressUrls)("http", port);
+        const urls = (0, import_shared.getAddressUrls)(https ? "https" : "http", port);
         if (printURLs) {
           const routes = (0, import_shared.formatRoutes)(
             context.entry,

package/dist/server/proxy.d.ts

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

package/dist/server/restart.js

@@ -52,7 +52,10 @@ const restartDevServer = async ({ filePath }) => {
   for (const cleaner of cleaners) {
     await cleaner();
   }
-  const rsbuild = await (0, import_commands.init)();
+  const rsbuild = await (0, import_commands.init)({ isRestart: true });
+  if (!rsbuild) {
+    return;
+  }
   await rsbuild.startDevServer();
 };
 // Annotate the CommonJS export names for ESM import in node:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "0.0.28",
+  "version": "0.1.1",
   "description": "Unleash the power of Rspack with the out-of-the-box build tool.",
   "homepage": "https://rsbuild.dev",
   "bugs": {
@@ -58,19 +58,19 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "0.3.14",
+    "@rspack/core": "0.4.0",
     "core-js": "~3.32.2",
     "html-webpack-plugin": "npm:html-rspack-plugin@5.5.7",
     "postcss": "8.4.31",
     "semver": "^7.5.4",
     "ws": "^8.2.0",
-    "@rsbuild/shared": "0.0.28"
+    "@rsbuild/shared": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^16",
     "@types/ws": "^8.2.0",
     "@types/semver": "^7.5.4",
-    "typescript": "^5.2.2"
+    "typescript": "^5.3.0"
   },
   "engines": {
     "node": ">=14.0.0"

package/dist/server/https.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import { type DevServerHttpsOptions } from '@rsbuild/shared';
-export declare const genHttpsOptions: (userOptions: DevServerHttpsOptions, pwd: string) => Promise<{
-  key?: Buffer | string;
-  cert?: Buffer | string;
-}>;

package/dist/server/https.js

@@ -1,50 +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 https_exports = {};
-__export(https_exports, {
-  genHttpsOptions: () => genHttpsOptions
-});
-module.exports = __toCommonJS(https_exports);
-var import_shared = require("@rsbuild/shared");
-const genHttpsOptions = async (userOptions, pwd) => {
-  const httpsOptions = typeof userOptions === "boolean" ? {} : userOptions;
-  if (!httpsOptions.key || !httpsOptions.cert) {
-    let devcertPath;
-    try {
-      devcertPath = require.resolve("devcert", { paths: [pwd, __dirname] });
-    } catch (err) {
-      const command = import_shared.color.bold(import_shared.color.yellow(`npm add devcert@1.2.2 -D`));
-      import_shared.logger.error(
-        `You have enabled "dev.https" option, but the "devcert" package is not installed.`
-      );
-      import_shared.logger.error(
-        `Please run ${command} to install manually, otherwise the https can not work.`
-      );
-      throw new Error('[https] "devcert" is not found.');
-    }
-    const devcert = require(devcertPath);
-    const selfsign = await devcert.certificateFor(["localhost"]);
-    return selfsign;
-  }
-  return httpsOptions;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  genHttpsOptions
-});