@rsbuild/core 0.0.17 → 0.0.18

package/dist/server/dev-middleware/hmr-client/index.js

@@ -0,0 +1,164 @@
+"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 __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 import_strip_ansi = __toESM(require("strip-ansi"));
+var import_format_stats = require("@rsbuild/shared/format-stats");
+var import_createSocketUrl = require("./createSocketUrl");
+const hadRuntimeError = false;
+const socketUrl = (0, import_createSocketUrl.createSocketUrl)(__resourceQuery);
+const connection = new WebSocket(socketUrl);
+connection.onopen = function() {
+  if (typeof console !== "undefined" && typeof console.info === "function") {
+    console.info("[HMR] connected.");
+  }
+};
+connection.onclose = function() {
+  if (typeof console !== "undefined" && typeof console.info === "function") {
+    console.info("[HMR] disconnected. Refresh the page if necessary.");
+  }
+};
+let isFirstCompilation = true;
+let mostRecentCompilationHash = null;
+let hasCompileErrors = false;
+function clearOutdatedErrors() {
+  if (typeof console !== "undefined" && typeof console.clear === "function") {
+    if (hasCompileErrors) {
+      console.clear();
+    }
+  }
+}
+function handleSuccess() {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleWarnings(warnings) {
+  clearOutdatedErrors();
+  const isHotUpdate = !isFirstCompilation;
+  isFirstCompilation = false;
+  hasCompileErrors = false;
+  function printWarnings() {
+    const formatted = (0, import_format_stats.formatStatsMessages)({
+      warnings,
+      errors: []
+    });
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+      for (let i = 0; i < formatted.warnings.length; i++) {
+        if (i === 5) {
+          console.warn(
+            "There were more warnings in other files.\nYou can find a complete log in the terminal."
+          );
+          break;
+        }
+        console.warn((0, import_strip_ansi.default)(formatted.warnings[i]));
+      }
+    }
+  }
+  printWarnings();
+  if (isHotUpdate) {
+    tryApplyUpdates();
+  }
+}
+function handleErrors(errors) {
+  clearOutdatedErrors();
+  isFirstCompilation = false;
+  hasCompileErrors = true;
+  const formatted = (0, import_format_stats.formatStatsMessages)({
+    errors,
+    warnings: []
+  });
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    for (const error of formatted.errors) {
+      console.error((0, import_strip_ansi.default)(error));
+    }
+  }
+}
+function handleAvailableHash(hash) {
+  mostRecentCompilationHash = hash;
+}
+connection.onmessage = function(e) {
+  const message = JSON.parse(e.data);
+  switch (message.type) {
+    case "hash":
+      handleAvailableHash(message.data);
+      break;
+    case "still-ok":
+    case "ok":
+      handleSuccess();
+      break;
+    case "content-changed":
+      window.location.reload();
+      break;
+    case "warnings":
+      handleWarnings(message.data);
+      break;
+    case "errors":
+      handleErrors(message.data);
+      break;
+    default:
+  }
+};
+function isUpdateAvailable() {
+  return mostRecentCompilationHash !== __webpack_hash__;
+}
+function canApplyUpdates() {
+  return module.hot.status() === "idle";
+}
+function tryApplyUpdates() {
+  if (!module.hot) {
+    window.location.reload();
+    return;
+  }
+  if (!isUpdateAvailable() || !canApplyUpdates()) {
+    return;
+  }
+  function handleApplyUpdates(err, updatedModules) {
+    const wantsForcedReload = err || !updatedModules || hadRuntimeError;
+    if (wantsForcedReload) {
+      window.location.reload();
+      return;
+    }
+    if (isUpdateAvailable()) {
+      tryApplyUpdates();
+    }
+  }
+  const result = module.hot.check(
+    /* autoApply */
+    true,
+    handleApplyUpdates
+  );
+  if (result == null ? void 0 : result.then) {
+    result.then(
+      (updatedModules) => {
+        handleApplyUpdates(null, updatedModules);
+      },
+      (err) => {
+        handleApplyUpdates(err, null);
+      }
+    );
+  }
+}

package/dist/server/dev-middleware/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server } from 'http';
+import { EventEmitter } from 'events';
+import type { DevServerOptions, DevMiddlewareAPI, DevMiddleware as CustomDevMiddleware } from '@rsbuild/shared';
+type Options = {
+  dev: DevServerOptions;
+  devMiddleware?: CustomDevMiddleware;
+};
+export default class DevMiddleware extends EventEmitter {
+  middleware?: DevMiddlewareAPI;
+  private devOptions;
+  private socketServer;
+  constructor({
+    dev,
+    devMiddleware
+  }: Options);
+  init(app: Server): void;
+  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+  private setupDevMiddleware;
+}
+export {};

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

@@ -0,0 +1,90 @@
+"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 dev_middleware_exports = {};
+__export(dev_middleware_exports, {
+  default: () => DevMiddleware
+});
+module.exports = __toCommonJS(dev_middleware_exports);
+var import_events = require("events");
+var import_socketServer = __toESM(require("./socketServer"));
+const noop = () => {
+};
+function getHMRClientPath(client) {
+  const protocol = (client == null ? void 0 : client.protocol) ? `&protocol=${client.protocol}` : "";
+  const host = (client == null ? void 0 : client.host) ? `&host=${client.host}` : "";
+  const path = (client == null ? void 0 : client.path) ? `&path=${client.path}` : "";
+  const port = (client == null ? void 0 : client.port) ? `&port=${client.port}` : "";
+  const clientEntry = `${require.resolve("@rsbuild/core/hmr-client")}?${host}${path}${port}${protocol}`;
+  return clientEntry;
+}
+class DevMiddleware extends import_events.EventEmitter {
+  constructor({ dev, devMiddleware }) {
+    super();
+    this.devOptions = dev;
+    this.socketServer = new import_socketServer.default(dev);
+    if (devMiddleware) {
+      this.middleware = this.setupDevMiddleware(devMiddleware);
+    }
+  }
+  init(app) {
+    app.on("listening", () => {
+      this.socketServer.prepare(app);
+    });
+    app.on("close", async () => {
+      var _a;
+      (_a = this.middleware) == null ? void 0 : _a.close(noop);
+      this.socketServer.close();
+    });
+  }
+  sockWrite(type, data) {
+    this.socketServer.sockWrite(type, data);
+  }
+  setupDevMiddleware(devMiddleware) {
+    const { devOptions } = this;
+    const callbacks = {
+      onInvalid: () => {
+        this.socketServer.sockWrite("invalid");
+      },
+      onDone: (stats) => {
+        this.socketServer.updateStats(stats);
+        this.emit("change", stats);
+      }
+    };
+    const enableHMR = this.devOptions.hot || this.devOptions.liveReload;
+    const middleware = devMiddleware({
+      headers: devOptions.headers,
+      stats: false,
+      callbacks,
+      hmrClientPath: enableHMR ? getHMRClientPath(devOptions.client) : void 0,
+      serverSideRender: true,
+      ...devOptions.devMiddleware
+    });
+    return middleware;
+  }
+}

package/dist/server/dev-middleware/socketServer.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Server } from 'http';
+import ws from 'ws';
+import { Stats, DevServerOptions } from '@rsbuild/shared';
+export default class SocketServer {
+  private wsServer;
+  private readonly sockets;
+  private readonly options;
+  private app?;
+  private stats?;
+  private timer;
+  constructor(options: DevServerOptions);
+  prepare(app: Server): void;
+  updateStats(stats: Stats): void;
+  sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
+  singleWrite(socket: ws, type: string, data?: Record<string, any> | string | boolean): void;
+  close(): void;
+  private onConnect;
+  private getStats;
+  private sendStats;
+  private send;
+}

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;
+}>;