@rsbuild/core 0.0.16 → 0.0.18

package/dist/server/dev-middleware/socketServer.js

@@ -0,0 +1,167 @@
+"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 socketServer_exports = {};
+__export(socketServer_exports, {
+  default: () => SocketServer
+});
+module.exports = __toCommonJS(socketServer_exports);
+var import_ws = __toESM(require("ws"));
+var import_shared = require("@rsbuild/shared");
+class SocketServer {
+  constructor(options) {
+    this.sockets = [];
+    this.timer = null;
+    this.options = options;
+  }
+  // create socket, install socket handler, bind socket event
+  prepare(app) {
+    var _a;
+    this.app = app;
+    this.wsServer = new import_ws.default.Server({
+      noServer: true,
+      path: (_a = this.options.client) == null ? void 0 : _a.path
+    });
+    this.app.on("upgrade", (req, sock, head) => {
+      if (!this.wsServer.shouldHandle(req)) {
+        return;
+      }
+      this.wsServer.handleUpgrade(req, sock, head, (connection) => {
+        this.wsServer.emit("connection", connection, req);
+      });
+    });
+    this.wsServer.on("error", (err) => {
+      import_shared.logger.error(err);
+    });
+    this.timer = setInterval(() => {
+      this.wsServer.clients.forEach((socket) => {
+        const extWs = socket;
+        if (!extWs.isAlive) {
+          extWs.terminate();
+        } else {
+          extWs.isAlive = false;
+          extWs.ping(() => {
+          });
+        }
+      });
+    }, 3e4);
+    this.wsServer.on("connection", (socket) => {
+      this.onConnect(socket);
+    });
+  }
+  updateStats(stats) {
+    this.stats = stats;
+    this.sendStats();
+  }
+  // write message to each socket
+  sockWrite(type, data) {
+    this.sockets.forEach((socket) => {
+      this.send(socket, JSON.stringify({ type, data }));
+    });
+  }
+  singleWrite(socket, type, data) {
+    this.send(socket, JSON.stringify({ type, data }));
+  }
+  close() {
+    this.sockets.forEach((socket) => {
+      socket.close();
+    });
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  onConnect(socket) {
+    const connection = socket;
+    connection.isAlive = true;
+    connection.on("pong", () => {
+      connection.isAlive = true;
+    });
+    if (!connection) {
+      return;
+    }
+    this.sockets.push(connection);
+    connection.on("close", () => {
+      const idx = this.sockets.indexOf(connection);
+      if (idx >= 0) {
+        this.sockets.splice(idx, 1);
+      }
+    });
+    if (this.options.hot || this.options.hot === "only") {
+      this.singleWrite(connection, "hot");
+    }
+    if (this.options.liveReload) {
+      this.singleWrite(connection, "liveReload");
+    }
+    if (this.stats) {
+      this.sendStats(true);
+    }
+  }
+  // get standard stats
+  getStats() {
+    const curStats = this.stats;
+    if (!curStats) {
+      return null;
+    }
+    const defaultStats = {
+      all: false,
+      hash: true,
+      assets: true,
+      warnings: true,
+      errors: true,
+      errorDetails: false
+    };
+    return curStats.toJson(defaultStats);
+  }
+  // determine what message should send by stats
+  sendStats(force = false) {
+    const stats = this.getStats();
+    if (!stats) {
+      return null;
+    }
+    const shouldEmit = !force && stats && (!stats.errors || stats.errors.length === 0) && stats.assets && stats.assets.every((asset) => !asset.emitted);
+    if (shouldEmit) {
+      return this.sockWrite("still-ok");
+    }
+    this.sockWrite("hash", stats.hash);
+    if (stats.errors && stats.errors.length > 0) {
+      return this.sockWrite("errors", stats.errors);
+    } else if (stats.warnings && stats.warnings.length > 0) {
+      return this.sockWrite("warnings", stats.warnings);
+    } else {
+      return this.sockWrite("ok");
+    }
+  }
+  // send message to connecting socket
+  send(connection, message) {
+    if (connection.readyState !== 1) {
+      return;
+    }
+    connection.send(message);
+  }
+}

package/dist/server/devServer.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server } from 'http';
+import type { ListenOptions } from 'net';
+import { RsbuildDevServerOptions, CreateDevServerOptions, ServerApi } from '@rsbuild/shared';
+import connect from 'connect';
+export declare class RsbuildDevServer {
+  private readonly dev;
+  private readonly devMiddleware;
+  private pwd;
+  private app;
+  middlewares: connect.Server;
+  constructor(options: RsbuildDevServerOptions);
+  private getDevOptions;
+  private applySetupMiddlewares;
+  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;
+  close(): void;
+}
+export declare function createDevServer(options: CreateDevServerOptions): Promise<ServerApi>;

package/dist/server/devServer.js

@@ -0,0 +1,172 @@
+"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 devServer_exports = {};
+__export(devServer_exports, {
+  RsbuildDevServer: () => RsbuildDevServer,
+  createDevServer: () => createDevServer
+});
+module.exports = __toCommonJS(devServer_exports);
+var import_http = require("http");
+var import_https = require("https");
+var import_url = __toESM(require("url"));
+var import_shared = require("@rsbuild/shared");
+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"));
+class RsbuildDevServer {
+  constructor(options) {
+    this.middlewares = (0, import_connect.default)();
+    this.pwd = options.pwd;
+    this.dev = this.getDevOptions(options);
+    this.devMiddleware = new import_dev_middleware.default({
+      dev: this.dev,
+      devMiddleware: options.devMiddleware
+    });
+  }
+  getDevOptions(options) {
+    const devOptions = typeof options.dev === "boolean" ? {} : options.dev;
+    const defaultOptions = (0, import_constants.getDefaultDevOptions)();
+    return (0, import_deepmerge.deepmerge)(defaultOptions, devOptions);
+  }
+  applySetupMiddlewares() {
+    const setupMiddlewares = this.dev.setupMiddlewares || [];
+    const serverOptions = {
+      sockWrite: (type, data) => this.devMiddleware.sockWrite(type, data)
+    };
+    const before = [];
+    const after = [];
+    setupMiddlewares.forEach((handler) => {
+      handler(
+        {
+          unshift: (...handlers) => before.unshift(...handlers),
+          push: (...handlers) => after.push(...handlers)
+        },
+        serverOptions
+      );
+    });
+    return { before, after };
+  }
+  // Complete the preparation of services
+  async onInit(app) {
+    this.app = app;
+    const { before, after } = this.applySetupMiddlewares();
+    before.forEach((fn) => this.middlewares.use(fn));
+    await this.applyDefaultMiddlewares(app);
+    after.forEach((fn) => this.middlewares.use(fn));
+  }
+  async applyDefaultMiddlewares(app) {
+    const { dev, devMiddleware } = this;
+    if (dev.compress) {
+      const { default: compression } = await Promise.resolve().then(() => __toESM(require("http-compression")));
+      this.middlewares.use((req, res, next) => {
+        compression({
+          gzip: true,
+          brotli: false
+        })(req, res, next);
+      });
+    }
+    this.middlewares.use((req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      const path = req.url ? import_url.default.parse(req.url).pathname : "";
+      if (path == null ? void 0 : path.includes("hot-update")) {
+        res.setHeader("Access-Control-Allow-Credentials", "false");
+      }
+      const confHeaders = dev.headers;
+      if (confHeaders) {
+        for (const [key, value] of Object.entries(confHeaders)) {
+          res.setHeader(key, value);
+        }
+      }
+      next();
+    });
+    devMiddleware.init(app);
+    devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
+    if (dev.historyApiFallback) {
+      const { default: connectHistoryApiFallback } = await Promise.resolve().then(() => __toESM(require("connect-history-api-fallback")));
+      const historyApiFallbackMiddleware = connectHistoryApiFallback(
+        // @ts-expect-error
+        typeof dev.historyApiFallback === "boolean" ? {} : dev.historyApiFallback
+      );
+      this.middlewares.use(historyApiFallbackMiddleware);
+      devMiddleware.middleware && this.middlewares.use(devMiddleware.middleware);
+    }
+  }
+  async createHTTPServer() {
+    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);
+    } else {
+      return (0, import_http.createServer)(this.middlewares);
+    }
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(options || 8080, callback);
+    }
+  }
+  close() {
+    this.app.close();
+  }
+}
+async function createDevServer(options) {
+  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();
+    }
+  };
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsbuildDevServer,
+  createDevServer
+});

package/dist/server/https.d.ts

@@ -0,0 +1,6 @@
+/// <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

@@ -0,0 +1,50 @@
+"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
+});

package/dist/server/index.d.ts

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

package/dist/server/index.js

@@ -0,0 +1,31 @@
+"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 server_exports = {};
+__export(server_exports, {
+  createDevServer: () => import_devServer.createDevServer,
+  startProdServer: () => import_prodServer.startProdServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_devServer = require("./devServer");
+var import_prodServer = require("./prodServer");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServer,
+  startProdServer
+});

package/dist/server/prodServer.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ListenOptions } from 'net';
+import { Server } from 'http';
+import connect from 'connect';
+import { Context, RsbuildConfig, StartServerResult } from '@rsbuild/shared';
+type RsbuildProdServerOptions = {
+  pwd: string;
+  output: {
+    path: string;
+    assetPrefix?: string;
+  };
+};
+export declare class RsbuildProdServer {
+  private app;
+  private options;
+  middlewares: connect.Server;
+  constructor(options: RsbuildProdServerOptions);
+  onInit(app: Server): Promise<void>;
+  private applyDefaultMiddlewares;
+  createHTTPServer(): Promise<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): Promise<StartServerResult>;
+export {};

package/dist/server/prodServer.js

@@ -0,0 +1,133 @@
+"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 prodServer_exports = {};
+__export(prodServer_exports, {
+  RsbuildProdServer: () => RsbuildProdServer,
+  startProdServer: () => startProdServer
+});
+module.exports = __toCommonJS(prodServer_exports);
+var import_http = require("http");
+var import_connect = __toESM(require("connect"));
+var import_path = require("path");
+var import_sirv = __toESM(require("sirv"));
+var import_shared = require("@rsbuild/shared");
+class RsbuildProdServer {
+  constructor(options) {
+    this.middlewares = (0, import_connect.default)();
+    this.options = options;
+  }
+  // Complete the preparation of services
+  async onInit(app) {
+    this.app = app;
+    await this.applyDefaultMiddlewares();
+  }
+  async applyDefaultMiddlewares() {
+    const {
+      output: { path, assetPrefix },
+      pwd
+    } = this.options;
+    const assetMiddleware = (0, import_sirv.default)((0, import_path.join)(pwd, path), {
+      etag: true,
+      dev: true,
+      ignores: false
+    });
+    this.middlewares.use((req, res, next) => {
+      const url = req.url;
+      if (assetPrefix && (url == null ? void 0 : url.startsWith(assetPrefix))) {
+        req.url = url.slice(assetPrefix.length);
+        assetMiddleware(req, res, (...args) => {
+          req.url = url;
+          next(...args);
+        });
+      } else {
+        assetMiddleware(req, res, next);
+      }
+    });
+  }
+  async createHTTPServer() {
+    return (0, import_http.createServer)(this.middlewares);
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(options || 8080, callback);
+    }
+  }
+  close() {
+    this.app.close();
+  }
+}
+async function startProdServer(context, rsbuildConfig) {
+  var _a, _b, _c, _d;
+  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 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
+    }
+  });
+  const httpServer = await server.createHTTPServer();
+  await server.onInit(httpServer);
+  return new Promise((resolve) => {
+    server.listen(
+      {
+        host: import_shared.DEFAULT_DEV_HOST,
+        port
+      },
+      () => {
+        const urls = (0, import_shared.getAddressUrls)("http", port);
+        (0, import_shared.printServerURLs)(urls);
+        resolve({
+          port,
+          urls: urls.map((item) => item.url),
+          server: {
+            middlewares: server.middlewares,
+            close: () => {
+              server.close();
+            }
+            // TODO: decouple with Modern.js server
+          }
+        });
+      }
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RsbuildProdServer,
+  startProdServer
+});