@rsbuild/core 1.5.12 → 1.5.13

package/dist-types/configChain.d.ts

@@ -48,8 +48,6 @@ export declare const CHAIN_ID: {
         readonly STYLUS_INLINE: "stylus-inline";
         /** Rule for svg */
         readonly SVG: "svg";
-        /** Rule for pug */
-        readonly PUG: "pug";
         /** Rule for Vue */
         readonly VUE: "vue";
         /** Rule for wasm */
@@ -80,8 +78,6 @@ export declare const CHAIN_ID: {
         readonly STYLUS: "stylus";
         /** url-loader */
         readonly URL: "url";
-        /** pug-loader */
-        readonly PUG: "pug";
         /** vue-loader */
         readonly VUE: "vue";
         /** swc-loader */

package/dist-types/server/assets-middleware/getFileFromUrl.d.ts

@@ -0,0 +1,9 @@
+import type { Stats as FSStats } from 'node:fs';
+import type { EnvironmentContext } from '../../types';
+import type { OutputFileSystem } from './index';
+export declare function getFileFromUrl(url: string, outputFileSystem: OutputFileSystem, environments: Record<string, EnvironmentContext>): {
+    filename: string;
+    fsStats: FSStats;
+} | {
+    errorCode: number;
+} | undefined;

package/dist-types/server/assets-middleware/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The assets middleware is modified based on
+ * https://github.com/webpack/webpack-dev-middleware
+ *
+ * MIT Licensed
+ * Copyright JS Foundation and other contributors
+ * https://github.com/webpack/webpack-dev-middleware/blob/master/LICENSE
+ */
+import type { Stats as FSStats, ReadStream } from 'node:fs';
+import type { Compiler, MultiCompiler } from '@rspack/core';
+import type { InternalContext, NormalizedConfig, RequestHandler } from '../../types';
+import type { SocketServer } from '../socketServer';
+export type MultiWatching = ReturnType<MultiCompiler['watch']>;
+export type OutputFileSystem = {
+    createReadStream?: (p: string, opts: {
+        start: number;
+        end: number;
+    }) => ReadStream;
+    statSync?: (p: string) => FSStats;
+    readFileSync?: (p: string) => Buffer;
+};
+export type Options = {
+    writeToDisk?: boolean | ((targetPath: string, compilationName?: string) => boolean);
+};
+export type AssetsMiddlewareClose = (callback: (err?: Error | null) => void) => void;
+export type AssetsMiddleware = RequestHandler & {
+    watch: () => void;
+    close: AssetsMiddlewareClose;
+};
+export declare const isClientCompiler: (compiler: Compiler) => boolean;
+export declare const setupServerHooks: ({ compiler, token, socketServer, }: {
+    compiler: Compiler;
+    token: string;
+    socketServer: SocketServer;
+}) => void;
+/**
+ * The assets middleware handles compiler setup for development:
+ * - Call `compiler.watch`
+ * - Inject the HMR client path into page
+ * - Notify server when compiler hooks are triggered
+ */
+export declare const assetsMiddleware: ({ config, compiler, context, socketServer, resolvedPort, }: {
+    config: NormalizedConfig;
+    compiler: Compiler | MultiCompiler;
+    context: InternalContext;
+    socketServer: SocketServer;
+    resolvedPort: number;
+}) => Promise<AssetsMiddleware>;

package/dist-types/server/assets-middleware/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { InternalContext, RequestHandler } from '../../types';
+import type { OutputFileSystem } from './index';
+export declare function createMiddleware(context: InternalContext, ready: (callback: () => void) => void, outputFileSystem: OutputFileSystem): RequestHandler;

package/dist-types/server/assets-middleware/setupOutputFileSystem.d.ts

@@ -0,0 +1,4 @@
+import type { Compiler } from '@rspack/core';
+import type { OutputFileSystem } from './index';
+import type { ResolvedWriteToDisk } from './setupWriteToDisk';
+export declare function setupOutputFileSystem(writeToDisk: ResolvedWriteToDisk, compilers: Compiler[]): Promise<OutputFileSystem>;

package/dist-types/server/assets-middleware/setupWriteToDisk.d.ts

@@ -0,0 +1,15 @@
+import type { Compiler } from '@rspack/core';
+import type { EnvironmentContext, NormalizedDevConfig } from '../../types';
+declare module '@rspack/core' {
+    interface Compiler {
+        __hasRsbuildAssetEmittedCallback?: boolean;
+    }
+}
+export type ResolvedWriteToDisk = boolean | ((filePath: string, name?: string) => boolean);
+/**
+ * Resolve writeToDisk config across multiple environments.
+ * Returns the unified config if all environments have the same value,
+ * otherwise returns a function that resolves config based on compilation.
+ */
+export declare const resolveWriteToDiskConfig: (config: NormalizedDevConfig, environments: Record<string, EnvironmentContext>) => ResolvedWriteToDisk;
+export declare function setupWriteToDisk(compilers: Compiler[], writeToDisk: ResolvedWriteToDisk): void;

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

@@ -0,0 +1,7 @@
+import type { InternalContext, Rspack } from '../types';
+import type { ClientMessageError } from './socketServer';
+/**
+ * Formats error messages received from the browser into a log string with
+ * source location information.
+ */
+export declare const formatBrowserErrorLog: (message: ClientMessageError, context: InternalContext, fs: Rspack.OutputFileSystem) => Promise<string>;

package/dist-types/server/{compilationManager.d.ts → buildManager.d.ts}

@@ -1,28 +1,28 @@
-import type { EnvironmentContext, NormalizedConfig, Rspack } from '../types';
-import { type CompilationMiddleware } from './compilationMiddleware';
+import type { InternalContext, NormalizedConfig, Rspack } from '../types';
+import { type AssetsMiddleware } from './assets-middleware';
 import { SocketServer } from './socketServer';
 type Options = {
+    context: InternalContext;
     config: NormalizedConfig;
     compiler: Rspack.Compiler | Rspack.MultiCompiler;
     publicPaths: string[];
     resolvedPort: number;
-    environments: Record<string, EnvironmentContext>;
 };
 /**
- * Setup compiler-related logic:
- * 1. setup rsbuild-dev-middleware
+ * Setup compiler related logic:
+ * 1. setup assets middleware
  * 2. establish webSocket connect
  */
-export declare class CompilationManager {
-    middleware: CompilationMiddleware;
+export declare class BuildManager {
+    middleware: AssetsMiddleware;
     outputFileSystem: Rspack.OutputFileSystem;
-    private config;
+    socketServer: SocketServer;
     compiler: Rspack.Compiler | Rspack.MultiCompiler;
-    private environments;
+    private config;
     private publicPaths;
-    socketServer: SocketServer;
     private resolvedPort;
-    constructor({ config, compiler, publicPaths, resolvedPort, environments, }: Options);
+    private context;
+    constructor({ config, context, compiler, publicPaths, resolvedPort, }: Options);
     init(): Promise<void>;
     /**
      * Call `compiler.watch()` to start compiling.

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

@@ -1,11 +1,11 @@
 import type { InternalContext, NormalizedConfig, RequestHandler } from '../types';
-import type { CompilationManager } from './compilationManager';
+import type { BuildManager } from './buildManager';
 import type { RsbuildDevServer } from './devServer';
 import type { UpgradeEvent } from './helper';
 export type RsbuildDevMiddlewareOptions = {
     config: NormalizedConfig;
     context: InternalContext;
-    compilationManager?: CompilationManager;
+    buildManager?: BuildManager;
     devServerAPI: RsbuildDevServer;
     /**
      * Callbacks returned by the `onBeforeStartDevServer` hook.

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

@@ -1,14 +1,14 @@
 import type { Server } from 'node:http';
 import type { Http2SecureServer } from 'node:http2';
 import type { Connect, CreateCompiler, CreateDevServerOptions, EnvironmentAPI, InternalContext, NormalizedConfig } from '../types';
-import type { SocketMessage } from './socketServer';
+import type { ServerMessage } from './socketServer';
 type HTTPServer = Server | Http2SecureServer;
-type ExtractSocketMessageData<T extends SocketMessage['type']> = Extract<SocketMessage, {
+type ExtractSocketMessageData<T extends ServerMessage['type']> = Extract<ServerMessage, {
     type: T;
 }> extends {
     data: infer D;
 } ? D : undefined;
-export type SockWrite = <T extends SocketMessage['type']>(type: T, data?: ExtractSocketMessageData<T>) => void;
+export type SockWrite = <T extends ServerMessage['type']>(type: T, data?: ExtractSocketMessageData<T>) => void;
 export type RsbuildDevServer = {
     /**
      * The `connect` app instance.

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

@@ -1,5 +1,5 @@
 import type { Connect, EnvironmentAPI, HtmlFallback, RequestHandler } from '../types';
-import type { CompilationManager } from './compilationManager';
+import type { BuildManager } from './buildManager';
 export declare const faviconFallbackMiddleware: RequestHandler;
 export declare const getRequestLoggerMiddleware: () => Connect.NextHandleFunction;
 export declare const notFoundMiddleware: RequestHandler;
@@ -9,7 +9,7 @@ export declare const optionsFallbackMiddleware: RequestHandler;
  */
 export declare const getHtmlCompletionMiddleware: (params: {
     distPath: string;
-    compilationManager: CompilationManager;
+    buildManager: BuildManager;
 }) => RequestHandler;
 /**
  * handle `server.base`
@@ -22,7 +22,7 @@ export declare const getBaseMiddleware: (params: {
  */
 export declare const getHtmlFallbackMiddleware: (params: {
     distPath: string;
-    compilationManager: CompilationManager;
+    buildManager: BuildManager;
     htmlFallback?: HtmlFallback;
 }) => RequestHandler;
 /**

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

@@ -1,51 +1,62 @@
 import type { IncomingMessage } from 'node:http';
 import type { Socket } from 'node:net';
-import type { DevConfig, EnvironmentContext, Rspack } from '../types';
-export type SocketMessageStaticChanged = {
+import type { DevConfig, InternalContext, Rspack } from '../types';
+export type ServerMessageStaticChanged = {
     type: 'static-changed' | 'content-changed';
 };
-export type SocketMessageHash = {
+export type ServerMessageHash = {
     type: 'hash';
     data: string;
 };
-export type SocketMessageOk = {
+export type ServerMessageOk = {
     type: 'ok';
 };
-export type SocketMessageWarnings = {
+export type ServerMessageWarnings = {
     type: 'warnings';
     data: {
         text: string[];
     };
 };
-export type SocketMessageErrors = {
+export type ServerMessageErrors = {
     type: 'errors';
     data: {
         text: string[];
         html: string;
     };
 };
-export type SocketMessage = SocketMessageOk | SocketMessageStaticChanged | SocketMessageHash | SocketMessageWarnings | SocketMessageErrors;
+export type ServerMessage = ServerMessageOk | ServerMessageStaticChanged | ServerMessageHash | ServerMessageWarnings | ServerMessageErrors;
+export type ClientMessageError = {
+    type: 'client-error';
+    message: string;
+    stack?: string;
+};
+export type ClientMessagePing = {
+    type: 'ping';
+};
+export type ClientMessage = ClientMessagePing | ClientMessageError;
 export declare class SocketServer {
     private wsServer;
     private readonly socketsMap;
     private readonly options;
+    private readonly context;
     private stats;
     private initialChunks;
     private heartbeatTimer;
-    private environments;
-    constructor(options: DevConfig, environments: Record<string, EnvironmentContext>);
+    private getOutputFileSystem;
+    private reportedBrowserLogs;
+    constructor(context: InternalContext, options: DevConfig, getOutputFileSystem: () => Rspack.OutputFileSystem);
     upgrade: (req: IncomingMessage, socket: Socket, head: Buffer) => void;
     private checkSockets;
     private clearHeartbeatTimer;
     prepare(): Promise<void>;
-    updateStats(stats: Rspack.Stats, token: string): void;
+    onBuildDone(stats: Rspack.Stats, token: string): void;
     /**
      * Write message to each socket
      * @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
      */
-    sockWrite(message: SocketMessage, token?: string): void;
+    sockWrite(message: ServerMessage, token?: string): void;
     close(): Promise<void>;
     private onConnect;
     private getStats;

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

@@ -1,10 +1,10 @@
 import type { FSWatcher } from '../../compiled/chokidar/index.js';
 import type { ChokidarOptions, NormalizedConfig } from '../types';
-import type { CompilationManager } from './compilationManager';
+import type { BuildManager } from './buildManager';
 type WatchFilesOptions = {
     root: string;
     config: NormalizedConfig;
-    compilationManager?: CompilationManager;
+    buildManager?: BuildManager;
 };
 export type WatchFilesResult = {
     close(): Promise<void>;

package/dist-types/types/config.d.ts

@@ -1131,7 +1131,7 @@ export type OutputStructure = 'flat' | 'nested';
 /**
  * custom properties
  * e.g. { name: 'viewport' content: 'width=500, initial-scale=1' }
- * */
+ */
 export type MetaAttrs = {
     [attrName: string]: string | boolean;
 };
@@ -1139,7 +1139,7 @@ export type MetaOptions = {
     /**
      * name content pair
      * e.g. { viewport: 'width=device-width, initial-scale=1, shrink-to-fit=no' }`
-     * */
+     */
     [name: string]: string | false | MetaAttrs;
 };
 export type HtmlBasicTag = {
@@ -1460,6 +1460,13 @@ export type CliShortcut = {
 };
 export type WriteToDisk = boolean | ((filename: string) => boolean);
 export interface DevConfig {
+    /**
+     * Enables forwarding of browser runtime errors to the terminal. When `true`, the dev
+     * client listens for window `error` events in the browser and send them to the dev server,
+     * where they are printed in the terminal (prefixed with `[browser]`).
+     * @default true
+     */
+    browserLogs?: boolean;
     /**
      * Whether to enable Hot Module Replacement.
      * @default true
@@ -1524,7 +1531,7 @@ export interface DevConfig {
      */
     lazyCompilation?: boolean | Rspack.LazyCompilationOptions;
 }
-export type NormalizedDevConfig = Omit<DevConfig, 'watchFiles'> & Required<Pick<DevConfig, 'hmr' | 'liveReload' | 'assetPrefix' | 'writeToDisk' | 'cliShortcuts'>> & {
+export type NormalizedDevConfig = Omit<DevConfig, 'watchFiles'> & Required<Pick<DevConfig, 'hmr' | 'liveReload' | 'assetPrefix' | 'writeToDisk' | 'cliShortcuts' | 'browserLogs'>> & {
     watchFiles: WatchFiles[];
     client: NormalizedClientConfig;
 };
@@ -1587,10 +1594,10 @@ export type RsbuildConfigMeta = {
 /**
  * Only some dev options can be defined in the environment config
  */
-export type AllowedEnvironmentDevKeys = 'hmr' | 'client' | 'liveReload' | 'assetPrefix' | 'progressBar' | 'lazyCompilation' | 'writeToDisk';
+export type AllowedEnvironmentDevKeys = 'hmr' | 'client' | 'liveReload' | 'browserLogs' | 'assetPrefix' | 'progressBar' | 'lazyCompilation' | 'writeToDisk';
 /**
  * The Rsbuild config to run in the specified environment.
- * */
+ */
 export interface EnvironmentConfig {
     /**
      * Options for local development.
@@ -1636,7 +1643,7 @@ export interface EnvironmentConfig {
 export type LogLevel = 'info' | 'warn' | 'error' | 'silent';
 /**
  * The Rsbuild config.
- * */
+ */
 export interface RsbuildConfig extends EnvironmentConfig {
     /**
      * Specify the build mode for Rsbuild, as each mode has different default behavior and optimizations.

package/dist-types/types/context.d.ts

@@ -26,7 +26,8 @@ export type RsbuildContext = {
      *     // ...
      *   });
      *   await rsbuild.startDevServer();
-     *   console.log(rsbuild.context.devServer); // { hostname: 'localhost', port: 3000, https: false }
+     *   console.log(rsbuild.context.devServer);
+     *   // { hostname: 'localhost', port: 3000, https: false }
      * }
      * ```
      */
@@ -58,6 +59,13 @@ export type RsbuildContext = {
      */
     callerName: string;
 };
+export type BuildStatus = 'idle' | 'building' | 'done';
+export type BuildState = {
+    /** Current build status */
+    status: BuildStatus;
+    /** Whether there are build errors */
+    hasErrors: boolean;
+};
 /** The inner context. */
 export type InternalContext = RsbuildContext & {
     /** All hooks. */
@@ -70,12 +78,14 @@ export type InternalContext = RsbuildContext & {
     normalizedConfig?: NormalizedConfig;
     /**
      * Get the plugin API.
-     *
-     * When environment is undefined, the global plugin API is returned, which can be used in all environments.
-     * */
+     * When environment is undefined, the global plugin API is returned, which
+     * can be used in all environments.
+     */
     getPluginAPI?: (environment?: string) => RsbuildPluginAPI;
     /** The environment context. */
     environments: Record<string, EnvironmentContext>;
     /** Only build specified environment. */
     specifiedEnvironments?: string[];
+    /** Build state information */
+    buildState: BuildState;
 };

package/dist-types/types/plugin.d.ts

@@ -102,7 +102,7 @@ export type ModifyWebpackChainUtils = ModifyChainUtils & {
     CHAIN_ID: ChainIdentifier;
     /**
      * @deprecated Use target instead.
-     * */
+     */
     name: string;
     /**
      * @deprecated Use HtmlPlugin instead.

package/dist-types/types/rsbuild.d.ts

@@ -13,6 +13,7 @@ export type Bundler = 'rspack' | 'webpack';
 export type StartDevServerOptions = {
     /**
      * Using a custom Rspack Compiler object.
+     * @deprecated This is no longer supported and will be removed in a future version.
      */
     compiler?: Compiler | MultiCompiler;
     /**
@@ -48,6 +49,7 @@ export type BuildOptions = {
     watch?: boolean;
     /**
      * Using a custom Rspack Compiler object.
+     * @deprecated This is no longer supported and will be removed in a future version.
      */
     compiler?: Compiler | MultiCompiler;
 };
@@ -131,11 +133,16 @@ export type CreateRsbuildOptions = {
      * If not specified or passing an empty array, all environments will be built.
      */
     environment?: string[];
+    /**
+     * Alias for `config`.
+     * This option will be deprecated in the future.
+     */
+    rsbuildConfig?: RsbuildConfig | (() => Promise<RsbuildConfig>);
     /**
      * Rsbuild configurations.
      * Passing a function to load the config asynchronously with custom logic.
      */
-    rsbuildConfig?: RsbuildConfig | (() => Promise<RsbuildConfig>);
+    config?: RsbuildConfig | (() => Promise<RsbuildConfig>);
     /**
      * Whether to call `loadEnv` to load environment variables and define them
      * as global variables via `source.define`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "1.5.12",
+  "version": "1.5.13",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -46,7 +46,7 @@
     "types.d.ts"
   ],
   "dependencies": {
-    "@rspack/core": "1.5.7",
+    "@rspack/core": "1.5.8",
     "@rspack/lite-tapable": "~1.0.1",
     "@swc/helpers": "^0.5.17",
     "core-js": "~3.45.1",
@@ -54,6 +54,7 @@
   },
   "devDependencies": {
     "@jridgewell/remapping": "^2.3.5",
+    "@jridgewell/trace-mapping": "^0.3.31",
     "@rslib/core": "0.14.0",
     "@types/connect": "3.4.38",
     "@types/cors": "^2.8.19",
@@ -73,7 +74,7 @@
     "html-rspack-plugin": "6.1.3",
     "http-proxy-middleware": "^2.0.9",
     "launch-editor-middleware": "^2.11.1",
-    "memfs": "^4.42.0",
+    "memfs": "^4.47.0",
     "mrmime": "^2.0.1",
     "on-finished": "2.4.1",
     "open": "^10.2.0",
@@ -88,6 +89,7 @@
     "rspack-chain": "^1.4.1",
     "rspack-manifest-plugin": "5.1.0",
     "sirv": "^3.0.2",
+    "stacktrace-parser": "^0.1.11",
     "style-loader": "3.3.4",
     "tinyglobby": "0.2.14",
     "typescript": "^5.9.2",

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

@@ -1,53 +0,0 @@
-/**
- * The dev middleware is modified based on
- * https://github.com/webpack/webpack-dev-middleware
- *
- * MIT Licensed
- * Copyright JS Foundation and other contributors
- * https://github.com/webpack/webpack-dev-middleware/blob/master/LICENSE
- */
-import type { Stats as FSStats, ReadStream } from 'node:fs';
-import type { ServerResponse as NodeServerResponse } from 'node:http';
-import type { Compiler, Configuration, MultiCompiler, MultiStats, Stats, Watching } from '@rspack/core';
-import type { RequestHandler } from '../types';
-export type ServerResponse = NodeServerResponse & {
-    locals?: {
-        webpack?: {
-            devMiddleware?: Context;
-        };
-    };
-};
-export type MultiWatching = ReturnType<MultiCompiler['watch']>;
-export type OutputFileSystem = {
-    createReadStream?: (p: string, opts: {
-        start: number;
-        end: number;
-    }) => ReadStream;
-    statSync?: (p: string) => FSStats;
-    lstat?: (p: string) => unknown;
-    readFileSync?: (p: string) => Buffer;
-};
-export type Callback = (stats?: Stats | MultiStats) => void;
-export type Options = {
-    writeToDisk?: boolean | ((targetPath: string, compilationName?: string) => boolean);
-    publicPath?: NonNullable<Configuration['output']>['publicPath'];
-};
-export type Context = {
-    state: boolean;
-    stats: Stats | MultiStats | undefined;
-    callbacks: Callback[];
-    options: Options;
-    compilers: Compiler[];
-    watching: Watching | MultiWatching | undefined;
-    outputFileSystem: OutputFileSystem;
-};
-export type FilledContext = Omit<Context, 'watching'> & {
-    watching: Watching | MultiWatching;
-};
-export type Close = (callback: (err: Error | null | undefined) => void) => void;
-export type API = RequestHandler & {
-    watch: () => void;
-    close: Close;
-};
-export type WithOptional<T, K extends keyof T> = Omit<T, K> & Partial<T>;
-export declare function devMiddleware(compiler: Compiler | MultiCompiler, options?: Options): Promise<API>;

package/dist-types/dev-middleware/middleware.d.ts

@@ -1,3 +0,0 @@
-import type { RequestHandler } from '../types';
-import type { FilledContext } from './index';
-export declare function wrapper(context: FilledContext): RequestHandler;

package/dist-types/dev-middleware/utils/getFilenameFromUrl.d.ts

@@ -1,7 +0,0 @@
-import type { Stats } from 'node:fs';
-import type { FilledContext } from '../index';
-export type Extra = {
-    stats?: Stats;
-    errorCode?: number;
-};
-export declare function getFilenameFromUrl(context: FilledContext, url: string, extra?: Extra): string | undefined;

package/dist-types/dev-middleware/utils/getPaths.d.ts

@@ -1,7 +0,0 @@
-import type { FilledContext } from '../index';
-type PublicPathInfo = {
-    outputPath: string;
-    publicPath: string | undefined;
-};
-export declare function getPaths(context: FilledContext): PublicPathInfo[];
-export {};

package/dist-types/dev-middleware/utils/ready.d.ts

@@ -1,2 +0,0 @@
-import type { FilledContext } from '../index';
-export declare function ready(context: FilledContext, callback: (...args: any[]) => any): void;

package/dist-types/dev-middleware/utils/setupHooks.d.ts

@@ -1,3 +0,0 @@
-import type { Compiler, MultiCompiler } from '@rspack/core';
-import type { Context, WithOptional } from '../index';
-export declare function setupHooks(context: WithOptional<Context, 'watching' | 'outputFileSystem'>, compiler: Compiler | MultiCompiler): void;

package/dist-types/dev-middleware/utils/setupOutputFileSystem.d.ts

@@ -1,3 +0,0 @@
-import type { Compiler } from '@rspack/core';
-import type { Options, OutputFileSystem } from '../index';
-export declare function setupOutputFileSystem(options: Options, compilers: Compiler[]): Promise<OutputFileSystem>;

package/dist-types/dev-middleware/utils/setupWriteToDisk.d.ts

@@ -1,7 +0,0 @@
-import type { Context, WithOptional } from '../index';
-declare module '@rspack/core' {
-    interface Compiler {
-        __hasRsbuildAssetEmittedCallback?: boolean;
-    }
-}
-export declare function setupWriteToDisk(context: WithOptional<Context, 'watching' | 'outputFileSystem'>): void;

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

@@ -1,36 +0,0 @@
-import type { Compiler, MultiCompiler, Stats } from '@rspack/core';
-import type { Connect, EnvironmentContext, NormalizedConfig } from '../types';
-export declare const isClientCompiler: (compiler: {
-    options: {
-        target?: Compiler["options"]["target"];
-    };
-}) => boolean;
-export type ServerCallbacks = {
-    onInvalid: (token: string, fileName?: string | null) => void;
-    onDone: (token: string, stats: Stats) => void;
-};
-export declare const setupServerHooks: ({ compiler, token, callbacks: { onDone, onInvalid }, }: {
-    compiler: Compiler;
-    token: string;
-    callbacks: ServerCallbacks;
-}) => void;
-export type CompilationMiddleware = Connect.NextHandleFunction & {
-    close: (callback: (err: Error | null | undefined) => void) => any;
-    watch: () => void;
-};
-/**
- * The CompilationMiddleware handles compiler setup for development:
- * - Call `compiler.watch` (handled by rsbuild-dev-middleware)
- * - Inject the HMR client path into page
- * - Notify server when compiler hooks are triggered
- */
-export declare const getCompilationMiddleware: ({ config, compiler, callbacks, environments, resolvedPort, }: {
-    config: NormalizedConfig;
-    compiler: Compiler | MultiCompiler;
-    /**
-     * Should trigger when compiler hook called
-     */
-    callbacks: ServerCallbacks;
-    environments: Record<string, EnvironmentContext>;
-    resolvedPort: number;
-}) => Promise<CompilationMiddleware>;