@rsbuild/core 2.0.8 → 2.0.9

package/dist-types/server/devServer.d.ts

@@ -12,36 +12,31 @@ type ExtractSocketMessageData<T extends ServerMessage['type']> = 'data' extends
 export type HotSend = <T extends ServerMessage['type']>(type: T, data?: ExtractSocketMessageData<T>) => void;
 export type RsbuildDevServer = RsbuildServerBase & {
     /**
-     * Notifies Rsbuild that the custom server has successfully started.
-     * Rsbuild will trigger the `onAfterStartDevServer` hook at this stage.
-     */
-    afterListen: () => Promise<void>;
+   * Notifies Rsbuild that the custom server has successfully started.
+   * Rsbuild will trigger the `onAfterStartDevServer` hook at this stage.
+   */ afterListen: () => Promise<void>;
     /**
-     * Activate socket connection.
-     * This ensures that HMR works properly.
-     */
-    connectWebSocket: (options: {
+   * Activate socket connection.
+   * This ensures that HMR works properly.
+   */ connectWebSocket: (options: {
         server: HTTPServer;
     }) => void;
     /**
-     * Environment API of Rsbuild server.
-     */
-    environments: EnvironmentAPI;
+   * Environment API of Rsbuild server.
+   */ environments: EnvironmentAPI;
     /**
-     * Start listening on the Rsbuild dev server.
-     * Do not call this method if you are using a custom server.
-     */
-    listen: () => Promise<StartDevServerResult>;
+   * Start listening on the Rsbuild dev server.
+   * Do not call this method if you are using a custom server.
+   */ listen: () => Promise<StartDevServerResult>;
     /**
-     * Allows middleware to send some message to HMR client, and then the HMR
-     * client will take different actions depending on the message type.
-     * - `full-reload`: The page will reload.
-     * - `static-changed`: Alias of `full-reload` for backward compatibility.
-     * - `custom`: Send custom messages via `custom` type with optional data to the browser and handle them via HMR events.
-     */
-    sockWrite: HotSend;
+   * Allows middleware to send some message to HMR client, and then the HMR
+   * client will take different actions depending on the message type.
+   * - `full-reload`: The page will reload.
+   * - `static-changed`: Alias of `full-reload` for backward compatibility.
+   * - `custom`: Send custom messages via `custom` type with optional data to the browser and handle them via HMR events.
+   */ sockWrite: HotSend;
 };
 export declare function createDevServer<Options extends {
     context: InternalContext;
 }>(options: Options, createCompiler: CreateCompiler, config: NormalizedConfig, { getPortSilently, runCompile }?: CreateDevServerOptions): Promise<RsbuildDevServer>;
-export {};
+export { };

package/dist-types/server/gracefulShutdown.d.ts

@@ -1,10 +1,8 @@
 /**
  * Registers a cleanup callback to be executed before process termination
- */
-export declare const registerCleanup: (callback: () => Promise<void>) => void;
+ */ export declare const registerCleanup: (callback: () => Promise<void>) => void;
 export declare const removeCleanup: (callback: () => Promise<void>) => void;
 /**
  * Sets up listeners for termination signals and stdin end event
  * This should be called once during application initialization
- */
-export declare const setupGracefulShutdown: () => (() => void);
+ */ export declare const setupGracefulShutdown: () => (() => void);

package/dist-types/server/gzipMiddleware.d.ts

@@ -1,2 +1,2 @@
 import type { CompressOptions, RequestHandler } from '../types';
-export declare function gzipMiddleware({ filter, level, }?: CompressOptions): RequestHandler;
+export declare function gzipMiddleware({ filter, level }?: CompressOptions): RequestHandler;

package/dist-types/server/helper.d.ts

@@ -7,31 +7,31 @@ import type { RsbuildDevServer } from './devServer';
 import type { RsbuildPreviewServer } from './previewServer';
 /**
  * It used to subscribe http upgrade event
- */
-export type UpgradeEvent = (req: IncomingMessage, socket: Socket, head: any) => void;
+ */ export type UpgradeEvent = (req: IncomingMessage, socket: Socket, head: any) => void;
 export type ServerStartResult<T> = {
     /**
-     * The URLs that server is listening on.
-     */
-    urls: string[];
+   * The URLs that server is listening on.
+   */ urls: string[];
     /**
-     * The actual port used by the server.
-     */
-    port: number;
+   * The actual port used by the server.
+   */ port: number;
     /**
-     * The dev server or preview server instance.
-     */
-    server: T;
+   * The dev server or preview server instance.
+   */ server: T;
 };
 export type StartDevServerResult = ServerStartResult<RsbuildDevServer>;
 export type StartPreviewServerResult = ServerStartResult<RsbuildPreviewServer>;
+// remove repeat '/'
 export declare const normalizeUrl: (url: string) => string;
+// /a + /b => /a/b
 export declare const joinUrlPath: (basePath: string, pathname: string) => string;
 export declare const isUrlPathUnderBase: (pathname: string, base: string) => boolean;
 export declare const removeBasePath: (url: string, base: string) => string;
 export declare const getRoutes: (context: InternalContext) => Routes;
-export declare const formatRoutes: (entry: RsbuildEntry, base: string, distPathPrefix: string | undefined, outputStructure: OutputStructure | undefined) => Routes;
-export declare function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, fallbackPathname, trailingLineBreak, originalConfig, logger, }: {
+/*
+ * format route by entry and adjust the index route to be the first
+ */ export declare const formatRoutes: (entry: RsbuildEntry, base: string, distPathPrefix: string | undefined, outputStructure: OutputStructure | undefined) => Routes;
+export declare function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, fallbackPathname, trailingLineBreak, originalConfig, logger }: {
     urls: {
         url: string;
         label: string;
@@ -51,8 +51,7 @@ export declare function printServerURLs({ urls: originalUrls, port, routes, prot
  * @param tryLimits - Maximum number of retries.
  * @param strictPort - Whether to throw an error when the port is occupied.
  * @returns Available port number.
- */
-export declare const getPort: ({ host, port, strictPort, tryLimits, }: {
+ */ export declare const getPort: ({ host, port, strictPort, tryLimits }: {
     host: string;
     port: string | number;
     strictPort: boolean;
@@ -68,7 +67,7 @@ type AddressUrl = {
     label: string;
     url: string;
 };
-export declare const getAddressUrls: ({ protocol, port, host, }: {
+export declare const getAddressUrls: ({ protocol, port, host }: {
     protocol: string;
     port: number;
     host?: string;
@@ -78,8 +77,7 @@ export declare function getServerTerminator(server: Server | Http2SecureServer):
  * Escape HTML characters
  * @example
  * escapeHtml('<div>Hello</div>') // '&lt;div&gt;Hello&lt;/div&gt;'
- */
-export declare function escapeHtml(text: string | null | undefined): string;
+ */ export declare function escapeHtml(text: string | null | undefined): string;
 export declare const HttpCode: {
     readonly Ok: 200;
     readonly NotModified: 304;
@@ -92,37 +90,30 @@ export declare const HttpCode: {
 };
 /**
  * The public server API shared by both the dev and preview servers.
- */
-export type RsbuildServerBase = {
+ */ export type RsbuildServerBase = {
     /**
-     * Close the server.
-     * In the dev server, this will call the `onCloseDevServer` hook.
-     */
-    close: () => Promise<void>;
+   * Close the server.
+   * In the dev server, this will call the `onCloseDevServer` hook.
+   */ close: () => Promise<void>;
     /**
-     * The Node.js HTTP server instance.
-     * - Will be `Http2SecureServer` if `server.https` config is used.
-     * - Will be `null` if `server.middlewareMode` is enabled.
-     */
-    httpServer: import('node:http').Server | import('node:http2').Http2SecureServer | null;
+   * The Node.js HTTP server instance.
+   * - Will be `Http2SecureServer` if `server.https` config is used.
+   * - Will be `null` if `server.middlewareMode` is enabled.
+   */ httpServer: import('node:http').Server | import('node:http2').Http2SecureServer | null;
     /**
-     * The `connect` app instance.
-     * Can be used to attach custom middlewares to the server.
-     */
-    middlewares: Connect.Server;
+   * The `connect` app instance.
+   * Can be used to attach custom middlewares to the server.
+   */ middlewares: Connect.Server;
     /**
-     * Open URL in the browser after starting the server.
-     */
-    open: () => Promise<void>;
+   * Open URL in the browser after starting the server.
+   */ open: () => Promise<void>;
     /**
-     * The resolved port.
-     * By default, Rsbuild server listens on port `3000` and automatically increments
-     * the port number if the port is occupied.
-     */
-    port: number;
+   * The resolved port.
+   * By default, Rsbuild server listens on port `3000` and automatically increments
+   * the port number if the port is occupied.
+   */ port: number;
     /**
-     * Print the server URLs.
-     */
-    printUrls: () => void;
+   * Print the server URLs.
+   */ printUrls: () => void;
 };
-export {};
+export { };

package/dist-types/server/historyApiFallback.d.ts

@@ -1,3 +1,10 @@
-import type { Logger } from '../logger';
+/**
+ * This module is modified based on source found in
+ * https://github.com/bripkens/connect-history-api-fallback
+ *
+ * MIT Licensed
+ * Copyright (c) 2022 Ben Blackmore and contributors
+ * https://github.com/bripkens/connect-history-api-fallback/blob/master/LICENSE
+ */ import type { Logger } from '../logger';
 import type { HistoryApiFallbackOptions, RequestHandler } from '../types';
 export declare function historyApiFallbackMiddleware(logger: Logger, options?: HistoryApiFallbackOptions): RequestHandler;

package/dist-types/server/httpServer.d.ts

@@ -1,7 +1,7 @@
 import type { Server } from 'node:http';
 import type { Http2SecureServer } from 'node:http2';
 import type { Connect, ServerConfig } from '../types';
-export declare const createHttpServer: ({ serverConfig, middlewares, }: {
+export declare const createHttpServer: ({ serverConfig, middlewares }: {
     serverConfig: ServerConfig;
     middlewares: Connect.Server;
 }) => Promise<Http2SecureServer | Server>;

package/dist-types/server/middlewares.d.ts

@@ -7,29 +7,25 @@ export declare const notFoundMiddleware: RequestHandler;
 export declare const optionsFallbackMiddleware: RequestHandler;
 /**
  * Support access HTML without suffix
- */
-export declare const getHtmlCompletionMiddleware: (params: {
+ */ export declare const getHtmlCompletionMiddleware: (params: {
     distPath: string;
     buildManager: BuildManager;
 }) => RequestHandler;
 /**
  * handle `server.base`
- */
-export declare const getBaseUrlMiddleware: (params: {
+ */ export declare const getBaseUrlMiddleware: (params: {
     base: string;
 }) => RequestHandler;
 /**
  * support HTML fallback in some edge cases
- */
-export declare const getHtmlFallbackMiddleware: (params: {
+ */ export declare const getHtmlFallbackMiddleware: (params: {
     distPath: string;
     buildManager: BuildManager;
     logger: Logger;
 }) => RequestHandler;
 /**
  * Support viewing served files via `/rsbuild-dev-server` route
- */
-export declare const viewingServedFilesMiddleware: (params: {
+ */ export declare const viewingServedFilesMiddleware: (params: {
     environments: EnvironmentAPI;
     logger: Logger;
 }) => RequestHandler;

package/dist-types/server/open.d.ts

@@ -2,7 +2,7 @@ import type { Logger } from '../logger';
 import type { NormalizedConfig, Routes } from '../types';
 export declare const replacePortPlaceholder: (url: string, port: number) => string;
 export declare function resolveUrl(str: string, base: string): string;
-export declare function open({ port, routes, config, protocol, clearCache, logger, }: {
+export declare function open({ port, routes, config, protocol, clearCache, logger }: {
     port: number;
     routes: Routes;
     config: NormalizedConfig;

package/dist-types/server/runner/basic.d.ts

@@ -18,11 +18,10 @@ export declare abstract class BasicRunner implements Runner {
     protected abstract createBaseModuleScope(): BasicModuleScope;
     protected abstract createModuleScope(requireFn: RunnerRequirer, m: ModuleObject, file: BasicRunnerFile): BasicModuleScope;
     /**
-     * Get the file information for a given module path.
-     *
-     * @returns An object containing the file path, content, and subPath, or null if the module is not an rspack output.
-     */
-    protected getFile(modulePath: string[] | string, currentDirectory: string): BasicRunnerFile | null;
+   * Get the file information for a given module path.
+   *
+   * @returns An object containing the file path, content, and subPath, or null if the module is not an rspack output.
+   */ protected getFile(modulePath: string[] | string, currentDirectory: string): BasicRunnerFile | null;
     protected preExecute(_code: string, _file: BasicRunnerFile): void;
     protected postExecute(_m: ModuleObject, _file: BasicRunnerFile): void;
     protected createRunner(): void;

package/dist-types/server/runner/index.d.ts

@@ -1,4 +1,6 @@
-import type { RunnerFactoryOptions } from './type';
+/**
+ * The following code is modified based on @rspack/test-tools/runner
+ */ import type { RunnerFactoryOptions } from './type';
 export declare const run: <T>({ bundlePath, ...runnerFactoryOptions }: RunnerFactoryOptions & {
     bundlePath: string;
 }) => Promise<T>;

package/dist-types/server/socketServer.d.ts

@@ -5,12 +5,11 @@ export type ServerMessageFullReload = {
     type: 'full-reload';
     data?: {
         /**
-         * If `path` ends with `.html`, only the matching page will reload.
-         * The HTML path should be relative to the dev server root and should not
-         * include `server.base`. Use `'*'` to reload all pages.
-         * @example `/foo.html`
-         */
-        path?: string;
+     * If `path` ends with `.html`, only the matching page will reload.
+     * The HTML path should be relative to the dev server root and should not
+     * include `server.base`. Use `'*'` to reload all pages.
+     * @example `/foo.html`
+     */ path?: string;
     };
 };
 export type ServerMessageStaticChanged = {
@@ -73,32 +72,39 @@ export declare class SocketServer {
     private reportedBrowserLogs;
     private currentHash;
     constructor(context: InternalContext, options: DevConfig, getOutputFileSystem: () => Rspack.OutputFileSystem);
+    // subscribe upgrade event to handle socket
     upgrade: (req: IncomingMessage, socket: Socket, head: Buffer) => void;
+    // detect and close broken connections
+    // https://github.com/websockets/ws/blob/8.18.0/README.md#how-to-detect-and-close-broken-connections
     private checkSockets;
     private clearHeartbeatTimer;
+    // create socket, install socket handler, bind socket event
     prepare(): Promise<void>;
     onBuildDone(): void;
     /**
-     * Send error messages to the client.
-     */
-    sendError(errors: Rspack.StatsError[], token: string): void;
+   * Send error messages to the client.
+   */ sendError(errors: Rspack.StatsError[], token: string): void;
     /**
-     * Send warning messages to the client
-     */
-    sendWarning(warnings: Rspack.StatsError[], token: string): void;
+   * Send warning messages to the client
+   */ sendWarning(warnings: Rspack.StatsError[], token: string): void;
     /**
-     * Send a server message to matching client sockets.
-     * @param message - The message to send
-     * @param token - The token of the socket to send the message to,
-     * if not provided, the message will be sent to all sockets
-     */
-    sendMessage(message: ServerMessage, token?: string): void;
+   * Send a server message to matching client sockets.
+   * @param message - The message to send
+   * @param token - The token of the socket to send the message to,
+   * if not provided, the message will be sent to all sockets
+   */ sendMessage(message: ServerMessage, token?: string): void;
     close(): Promise<void>;
     private onConnect;
     private getEnvironmentByToken;
     private getInitialChunks;
+    // Cache initial chunks for environments that have no baseline yet.
+    // This keeps comparison stable even when no client socket is connected
+    // during the first completed build.
     private ensureInitialChunks;
+    // Only use stats when environment is matched
     private getStats;
+    // determine what message should send by stats
     private sendStats;
+    // send a serialized message to a specific socket
     private sendRawMessage;
 }

package/dist-types/server/watchFiles.d.ts

@@ -11,4 +11,4 @@ export type WatchFilesResult = {
 };
 export declare function setupWatchFiles(options: WatchFilesOptions): Promise<WatchFilesResult | undefined>;
 export declare function createChokidar(pathOrGlobs: string[], root: string, options: ChokidarOptions): Promise<FSWatcher>;
-export {};
+export { };