@rsbuild/core 0.0.17 → 0.0.19

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,35 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Server } from 'http';
+import type { ListenOptions } from 'net';
+import { RsbuildDevServerOptions, CreateDevServerOptions, DevServerContext, StartDevServerOptions, StartServerResult } 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?: (err?: Error) => Promise<void>): void;
+  close(): void;
+}
+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>;